Java面向对象(三)

1.抽象类

(1)抽象类的概念:
针对一个事物,比如:动物类---->总体概括,之前定义一个具体的动物(---->必须给他的某个功能只是声明即可),只有,猫或者狗等等这些才是具体事物
Java中,如果一个类中有一个方法声明(抽象方法)抽象功能,那么这个类定义为抽象类

关键字: abstract 抽象的意思

(2)抽象类的特点: 抽象类不能直接实例化!(即不能创建对象)

(3)关于抽象类:

1)如果一个类中有抽象方法,那么这个类是一定是一个抽象类
2) 抽象类中不一定都是抽象方法

(4)抽象类的子类

1)如果子类是抽象类,没有意义,因为都不能实例化,对象如何创建

2)子类具体类,那么子类必须实现父类中的抽象功能.

(5)抽象类的成员特点:
成员变量: 可以是变量,也可以是一个常量
构造方法: 可以有无参,可以有有参,作用:给对象进行初始化的.
成员方法: 可以有抽象方法,还可以有非抽象方法

比如:

//定义一个抽象的人类
abstract class Person{
	
	private String name ;
	int num = 10 ; //变量
	public final int num2 = 100 ;//常量
	
	//无参构造
	public Person() {}
	
	//有参构造
	public Person(String name) {
		this.name = name ;
	}
	
	//非抽象的功能
	public void show() {
		System.out.println(num);
		System.out.println(num2);
	}
	
	//抽象功能
	public abstract void method();
}

(6)abstract和哪些关键字是冲突的(不能共有!)?

abstract 和private, abstract 和final, abstract和static

(7)猫狗案例抽象版

/**
 * 猫狗案例
		具体事物：猫，狗
		共性：姓名，年龄，吃饭
		
分析:具体到抽象
代码实现:从抽象到具体

分析:
		猫  Cat
			成员变量:name,age
			构造方法:无参/有参
			成员方法:setXXX/getXXX()  eat
			
		狗  Dog
			成员变量:name,age
			构造方法:无参/有参
			成员方法:setXXX/getXXX()  eat
			
		抽象的Animal类 :父类	 eat() ; 		
			
 * @author Administrator
 *
 */

 //抽象的动物类
public abstract class Animal {

	private String name ;
	private int age ;
	
	public Animal() {
		super();
	}

	public Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	//抽象功能
	public abstract void eat() ;
		
}

//猫类
public class Cat extends Animal {
	
	public Cat() {
		super();
	}

	public Cat(String name, int age) {
		super(name, age);
	}

	@Override
	public void eat() {
		System.out.println("猫吃鱼...");
	}
	
	//自己的功能
	public void playGame() {
		System.out.println("会玩毛线...");
	}

}

//狗类
public class Dog extends Animal {
	
	public Dog() {
		super();
	}

	public Dog(String name, int age) {
		super(name, age);
	}

	@Override
	public void eat() {
		System.out.println("狗吃骨头...");
	}
	
	public void lookDoor() {
		System.out.println("会看门...");
	}

}

//测试类
public class AnimalDemo {

	public static void main(String[] args) {
		
		//测试猫类
		//方式1:无参/set
		Animal a = new Cat() ; //抽象类多态
		a.setName("TOM");
		a.setAge(5);
		System.out.println("猫的姓名是:"+a.getName()+",年龄是:"+a.getAge());
		a.eat();
		//a.playGame() ;错误,多态的弊端就是父类不能访问子类特有功能!
		
		//要么向下转型,要么具体类创建具体类   
		Cat c = (Cat)a;
		c.playGame();
		
		System.out.println("------------------------");
		
		//方式2:带参构造创建对象 (具体类创建具体类对象)
		Cat c2 = new Cat("TOM", 3) ;
		System.out.println("猫的姓名是:"+c2.getName()+",年龄是:"+c2.getAge());
		c2.playGame();
		c2.eat();	
	}
}

2.接口

(1)接口:体现的是事物的扩展性功能(额外动作,后天经过学习等等)

(2)接口格式(接口:见名知意)
interface 接口名{
//抽象功能
public abstract void jump() ;// 接口中的方法不能有方法体,只能是抽象方法!
}

(3)接口的特点:不能实例化

(4)接口的子实现类:实现类 (具体的实现类)
class 类名+impl implements 接口名{

}
接口的子类如果是抽象类:没有意义,不能实例化

(5)创建对象

AniamlTrain at = new JumpCatImpl() ;//接口多态(实际开发中用的最多)

(6) 接口成员的特点:
成员变量: 是一个常量,不能更改,并且默认的修饰符 public static final
构造方法: 接口不存在构造方法
成员方法:都是抽象方法
默认的修饰符:public abstract

(7)( 面试题)接口和抽象类的区别:
A) 成员的区别
  成员变量:
   抽象类:既可以常量,也可以是变量
   接口:只能是常量,默认的修饰符:public static final
  构造方法:
   抽象类:有构造方法,无参/有参 (给对象进行初始化的)
   接口:没有构造方法
  成员方法:
   抽象类:可以有抽象方法,也可以有非抽象方法
   接口:只能是抽象方法 :默认的修饰符:public abstract

B)类与类/类与接口关系的区别
  类与类之间的关系:
   继承关系,只支持单继承,不支持多继承,但是可以多层继承
  类与接口的关系:
   实现关系,一个类继承另一个类的同时,还可以实现多个接口...
  接口与接口的关系:
是一种继承关系,既可以单继承,也可以多继承...
接口1 extends 接口2,接口3...

C)设计原则的区别
1)抽象类: 是有继承关系---->体现的是一种"is a"的关系   (A是B的一种或者B是A的一种)
   2)接口:类和接口:实现关系--->体现的是一种" like a"的关系(扩展功能) :跳高猫像猫

(8)猫狗案例接口版

/**
 * 猫狗案例,加入跳高的额外功能

分析:具体到抽象
实现:抽象到具体
		猫
			姓名   .年龄
			无参/有参
			setXXX
			eat(){}
			sleep(){}
			playGame(){}
		狗
			姓名   .年龄
			无参/有参
			setXXX
			eat(){}
			sleep(){}
			lookDoor(){}			
		Aniaml类 :abstract
			姓名   .年龄
			无参/有参
			setXXX/GetXXX()
			eat() ;
			sleep();
		
		最抽象:接口:里面跳高的功能
		跳高猫  继承 猫 实现  跳高的接口...
 							
 * @author Administrator
 *
 */

/**
 * 这是一个跳高的接口
 * @author Administrator
 *
 */
public interface Jump {
	
	//提供一个抽象功能
	public abstract void jump() ;
}

//抽象的动物类
public abstract class Animal {

	private String name ;
	private int age ;
	public Animal() {
		super();
	}
	public Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	//吃
	public abstract void eat();
	
	//睡
	public abstract void sleep() ;
				
}

//猫类
public class Cat extends Animal {
	
	public Cat() {
		super();
	}

	public Cat(String name, int age) {
		super(name, age);
	}

	@Override
	public void eat() {
		System.out.println("猫吃鱼....");
	}

	@Override
	public void sleep() {
		System.out.println("猫趴着睡觉....");
	}
	
	public void playGame() {
		System.out.println("猫玩游戏...");
	}

}

//狗类
public class Dog extends Animal {
	
	public Dog() {
		super();
	}

	public Dog(String name, int age) {
		super(name, age);
	}

	@Override
	public void eat() {
		System.out.println("狗吃猫...");
	}

	@Override
	public void sleep() {
		System.out.println("狗躺着睡觉...");
	}
	
	public void lookDoor() {
		System.out.println("狗躺着睡觉...");
	}

}

//跳高猫
public class JumpCat extends Cat implements Jump {
	
	public JumpCat() {
		super();
	}

	public JumpCat(String name, int age) {
		super(name, age);
	}

	@Override
	public void jump() {
		System.out.println("猫可以跳高了...");
	}

}

//跳高狗
public class JumpDog extends Dog  implements Jump {
	
	public JumpDog() {
		super();
	}

	public JumpDog(String name, int age) {
		super(name, age);
	}

	@Override
	public void jump() {
		System.out.println("狗可以跳高了...");
	}

}

 //测试类
public class AnimalTest {
	
	public static void main(String[] args) {
		//可以使用功能最多的类
		//创建具体类对象
		JumpCat jc = new JumpCat("tom", 5) ;
		System.out.println(jc.getName()+"---"+jc.getAge());
		jc.eat();
		jc.sleep();
		jc.playGame();
		jc.jump(); 
		
		System.out.println("------------------");
		
		//狗类自己测试
	}
}

3.形式参数和返回值的问题(一定要掌握!)

(1)形式参数问题

形式参数是基本类型,对实际参数没有影响

形式参数是引用类型:类(普通类),抽象类,接口

1)形式参数是一个类(具体类)

class Student{
	public void study() {
		System.out.println("Good Good Study,Day Day Up...");
	}
}

class StudentDemo{
	//成员方法
	public void method(Student s) {
		s.study(); 
	}
}

如何调用StudentDemo中的mehtod()方法?

public static void main(String[] args) {
		//在StudentDemo类中,method方法的形式参数是一个Student类(具体类)
		//如何调用StudentDemo中的mehtod()方法
		//1)创建StudentDemo对象
		StudentDemo sd = new StudentDemo() ;
		//2)需要创建Student的对象
		sd.method(new Student());
		System.out.println("----------------");
		
		//链式编程
		//匿名对象是可以作为参数传递的
		new StudentDemo().method(new Student());
	}

2)形式参数是一个抽象类

形式参数是一个抽象类:此时这块需要的是该抽象类的子类对象 (抽象类多态...)

//抽象的Person类
abstract class Person{
	public void teach() {
		System.out.println("今天天气不错,适合踢球...");
	}
}

class PersonDemo{
	public void method(Person p) { //不能直接创建对象 Person p =new Person();  可以采用抽象类多态的形式实现
		p.teach();
	}
}

如何调用PersonDemo类中的method()方法?

//首先需要提供Pereson类的子类
class Teacher extends Person{
	
}

//测试类
public class TeacherTest {

	public static void main(String[] args) {
		//需求:需要调用PersonDemo类中的method()方法
		//1)创建PersonDemo对象
		PersonDemo pd = new PersonDemo() ;
		//Perosn p = new  Person() ; //错误的,抽象类是不能实例化的
		//2)可以通过子类进行实例化
		Person p = new Teacher();
		pd.method(p);
	}
}

3)形式参数是一个接口

//定义一个接口
interface Inter{
	public abstract void study() ;
}

class InterDemo{
	public void show(Inter i) { //需要创建该接口对象,不能直接实例化 Inter i = new Inter() ;错误的
								//需要提供接口的子实现类,可以通过子实现类进行实例化:接口多态...
		i.study();
	}
}

如何调用InterDemo这个类中的show()方法?

//首先提供接口的子实现类
class Student2 implements Inter{

	@Override
	public void study() {
		System.out.println("Good Good Study ,Day Day Up ...");
	}
	
}

//测试类

public class StudentTest {

	public static void main(String[] args) {
		//需求:需要调用InterDemo这个类中的show()方法,如何调用
		//创建InterDemo类的对象
		InterDemo id = new InterDemo() ;
		//接口多态的形式创建Inter对象
		Inter i = new Student2() ;
		id.show(i);
		
	}
}

(2)返回值问题

如果返回值基本类型:用对应的基本类型去接收数据即可!

如果返回值引用类型:

类(具体类): 需要的是该类的对象

抽象类:那么返回需要的结果是需要当前抽象类的子类对象抽象类多态

接口:返回需要的结果是当前接口的子实现类对象接口多态

1)返回值是一个类

class Student3{
	public void study() {
		System.out.println("Good Good Study ,Day Day Up ...");
	}
}

class StudentDemo3{
	public Student3 method() {
		//需要提供一个该具体类的对象,是一个具体类的情况
		//方式1:匿名对象的方式
		//return new Student3();
		
		//方式2:具体类创建对象
		Student3 s = new Student3();
		return s ;
	}
}

2)返回值是一个抽象类

//抽象类:那么返回需要的结果是需要当前抽象类的子类对象 抽象类多态

abstract class Person2{
	 
	 public void show() {
		 System.out.println("今天天气不错");
	 }
 }
 //提供该抽象类的子类
 class Teacher2 extends Person2{
	 
 }
 
 class PersonDemo2{
	 public Person2 method() {
		 //返回值是一个抽象类
		 //return new Person2() ; 抽象类不能实例化 ,需要提供该抽象类的子类
		 //方式1:抽象类多态的形式创建对象
		 //Person2 p = new Teacher2() ;
		 //return p ;
		 
		 //方式2:匿名对象,还是通过子类实例化
		 return new Teacher2() ;	
	 }
 }

3 返回值是一个接口

//接口:返回需要的结果是需要当前接口的子实现类对象 接口多态

interface Inter2{
	public abstract void study();
}
//提供接口的子实现类
class InterImpl implements Inter2{

	@Override
	public void study() {
		System.out.println("好好学习,天天向上...");
	}	
}

class InterDemo2{
	public static Inter2 method() {
		
		//return new Inter2(); 接口不能实例化,提供接口的子实现类
		//return new InterImpl() ; //匿名对象的方式
		Inter2 i = new InterImpl();
		return i ;
	}
}

1.抽象类

2.接口

3.形式参数和返回值的问题(一定要掌握!)

猜你喜欢