Day09 多态 抽象方法 借口

今天的内容是基础班中的一个重点。

多态

知识点1.多态的三个前提：继承关系，方法重写，父类引用指向子类对象。

知识点2：成员变量在多态中：编译看左边，运行看左边。

成员方法在多态中：编译看左边，运行看右边。

静态方法在多态中：编译看左边，运行看右边。

知识点3：超人的例子，向上转型和向下转型

 

class demo3_superman {
	public static void main(String[] args) {
		person p = new superman();
		System.out.println(p.name);
		p.谈生意();
		superman sm = (superman)p;
		sm.fly();
	}
}
class person
{
	String name = "john";
	public void 谈生意(){
		System.out.println("谈生意");
	}

}
class superman extends person
{
	String name = "superman";
	public void 谈生意(){
		System.out.println("谈好几亿的大单子");
	}
	public void fly(){
		System.out.println("飞出去救人");
	}
}

 

 

 

 

 

多态的优点：利于扩展 利于维护

多态的缺点：

 

class demo4_animal {
	public static void main(String[] args) {
		
		method(new cat());
		method(new dog());
	}
	/*public static void method(cat c){
		c.eat();
	}*/
	public static void method(animal a){
		if (a instanceof cat)
		{
			cat c = (cat)a;
			c.eat();
			c.catchMouse();
		}else if (a instanceof dog)
		{
			dog d = (dog)a;
			d.eat();
			d.lookHome();
		}
	}
}
class animal
{
	public void eat(){
		System.out.println("Hello World!");	
	}
}
class cat extends animal
{
	public void eat(){
		System.out.println("猫吃鱼");
	}
	public void catchMouse(){
		System.out.println("猫捉老鼠");
	}
}
class dog extends animal
{
	public void eat(){
		System.out.println("狗吃肉");
	}
	public void lookHome(){
		System.out.println("狗看家");
	}
}

抽象类：

9.9 a:abstract class抽象类  public abstract void eat()抽象方法

b:抽象类不一定有抽象方法，有抽象方法的类一定在抽象类

C:抽象类不能实例化，如果实例化可以参开多态

D:抽象类的子类：只能是两种情况：① 抽象类 ② 重写了所有的抽象方法

 

class demo1_abstract {
	public static void main(String[] args) {
		animal a = new cat();
		a.eat();
	}
}
abstract class animal
{
	public abstract void eat();
}
class cat extends animal
{
	public void eat(){
		System.out.println("猫吃鱼");
	}
}

9.10 抽象类成员特点

 

抽象类的特点：a 成员变量：既可以变量 又可以常量，abstract 不能修饰变量

B：构造方法：有 C  成员方法：既可以抽象，也可以非抽象

抽象方法特性：抽象方法就是强制子类做的事情 

9.12 9.13 9.14 三个练习 找最后一个练习

 

abstract class teacher
{
	private String name;
	private int age;
	public teacher (){}
	public teacher (String name, int age){
			this.name = name;
			this.age= age;
	}
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
	public abstract void teach();
}
class baseteacher extends teacher
{
	public baseteacher (){}
	public baseteacher (String name, int age){
			super(name,age);
	}
	public void teach(){
		System.out.println("hahhhah");		
	}
}

 这个关于继承中有两个点需要记住：第一是子类继承时候的有参构造方法是super(..),第二是在子类里面 有时候会用到("名字是“+this,getName（）)，父类中中是直接加name 

 

9.15:面试题

①：一个没有抽象方法的类，能不能定义抽象类 。答案：可以的，作用就是不能直接创建对象，如果想创建对象就创建子类。

②：abstract不能喝static/final/private共存
9.16 接口

接口：a：interface 接口名{} 接口中的方法都是抽象的

b：class 类名 implements 接口名{} 

C:接口不能实例化，可以用多态的方法

D:接口的子类，可以是抽象类，没有意义，可以是具体类 ，重写所有的抽象方法。