Java基础第九讲

一、多态


   1.多态的前提


1)要有继承关系


2)要由方法重写


3)要由父类引用指向子类对象


   2.访问特点


1)成员变量


   编译看父类,运行看父类.


2)成员方法


   编译看父类,运行看子类.


3)静态方法


   编译看父类,运行看父类.


   3.多态的好处


1)提高代码的维护性


2)提高代码的扩展性


3.多态的弊端


   不能再使用子类的特有功能.

 

class TestAnimal{


	public static void main(String[] args){
	
			Person p = new SuperMan();
			System.out.println(p.name);
			p.谈生意();


			SuperMan sm = (SuperMan)p;
			sm.救人();
	}
}


class Person{
		String name = "John";
		public void 谈生意(){
			System.out.println("谈生意");
		}
}


class SuperMan extends Person {
		String name = "超人";
		public void 谈生意(){
			System.out.println("谈几个亿的生意");
		}


		public void 救人(){
			System.out.println("飞出去救人");
		}
}

4.多态的向上转型和向下转型


   向上转型相当于数据的默认类型转换,向下转型相当于数据的强制类型转换.


二、抽象类


   1.应用


1)类:abstract class 类名 { }


2)方法:public abstract void xxx();


   2.特点


1)如果定义了一个抽象类,其方法必须重写.


2)抽象类中不一定有抽象方法,但抽象方法的类一定是抽象类.


   3.注意事项


1)成员比昂两既可以是变量,也可以使常量.


2)有构造方法,用于子类访问父类数据的初始化.


3)成员方法既可以是抽象的,也可以使非抽象的.


4)一个抽象类如果没有抽象方法,也可以作为一个抽象类.这样其他类将不能再创建本类对象,只能由子类来完成.


5)abstract不能和private、static、final一起使用.

class TestTeacher{


	public static void main(String[] args){
			基础Teacher jc = new 基础Teacher("张三",23);
			jc.speak();


			就业Teacher jy = new 就业Teacher("李四",24);
			jy.speak();
	}
}


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 speak();					//讲课方法
}


class 基础Teacher extends Teacher{


	public 基础Teacher(){}


	public 基础Teacher(String name,int age){
		super(name,age);
	}


	public void speak(){
		System.out.println("我叫" + getName() + "我今年" + getAge() + "岁,我教se");
	}
}


class 就业Teacher extends Teacher{


	public 就业Teacher(){}


	public 就业Teacher(String name,int age){
		super(name,age);
	}


	public void speak(){
		System.out.println("我叫" + getName() + "我今年" + getAge() + "岁,我教ee");
	}
}

三、接口


   接口的成员比昂两只能是静态的常量.接口中定义的常量前面会默认省略public static fanal.接口中所有的方法都是抽象的,可直接写方法名: void xxx(){ }前面默认省略public abstract.


1.类与类之间的关系


   继承关系,只能单继承,或多层基层.


2.类与接口之间的关系


   实现关系,可以单实现也可以多实现.还可以在继承一个类的同时实现多个接口.


3.接口与接口之间的关系


   继承关系,可以单继承,也可以多继承.

class TestAnimal {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}


abstract class Animal {
	private String name;
	private int age;


	public Animal(){}


	public Animal(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 eat();


	public abstract void sleep();
}


interface Jump {
	public void jump();
}


class Cat extends Animal implements Jump {
	public Cat(){}


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


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


	public void sleep(){
		System.out.println("侧着睡");
	}


	public void jump() {
		System.out.println("猫跳高");
	}
}