目录

super关键字

super的使用，调用属性和方法

super调用构造器

多态性

多态的使用

为什么要使用多态

多态性只适用于方法不适用于属性

instanceof：向下转型

代码块

抽象类（abstract）

abstract修饰类:抽象类

abstract修饰方法:抽象方法

包含抽象方法的类一定是抽象类

super关键字

1.super理解为:父类的
2.super可以用来调用:属性、方法、构造器

super的使用，调用属性和方法
 

1. 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super. "
2. 特殊情况:当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式,表明调用的是父类中声明的属性。
3. 特殊情况:当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。

super调用构造器

• 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
• "super(形参列表)"的使用，必须声明在子类构造器的首行!
• 我们在类的构造器中，针对于"this（形参列表)"或"super(形参列表)"只能二选一，不能同时出现
• 在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()
   

多态性

定义三个类，man类和woman类继承于Person类

public class PersonTest {
	public static void main(String[] args) {
		//这就是多态性
        //父类的声明，子类的对象
		Person p1 =new man();
	}
}

理解多态性:可以理解为一个事物的多种形态

何为多态性:对象的多态性:父类的引用指向子类的对象
 

Person类

public class Person {
	String name;
	int age;
	public void eat() {
		System.out.println("人：吃饭");
	}
	public void walk() {
		System.out.println("人：走路");
	}
}

man类代码：

public class man extends Person{
	boolean isSmoking ;;
	public void earnMoney () {
		System.out.println("赚钱");
	}
	public void eat() {
		System.out.println("男人：吃饭");
	}
	public void walk() {
		System.out.println("男人：走路");
	}
}

woman类

public class woman extends Person{
	boolean isBeauty;
	public void goShopping () {
		System.out.println("败家");
	}
	public void eat() {
		System.out.println("女人：吃饭");
	}
	public void walk() {
		System.out.println("女人：走路");
	}
}

多态的使用

有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。

编译看左，运行看右（编译看左边父类的方法，运行看右边子类的方法）

当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法---虚拟方法调用

p1.eat();    // 输出为男人：吃饭

p1.walk();    //    男人：走路

//此时如果调用子类特有的方法会报错
p1.earnMoney();

多态的使用前提：①要有类的继承关系②进行了方法的重写

为什么要使用多态

通过代码理解，示例1：

public class AnimalTest {
	public static void main(String[] args) {
		AnimalTest test = new AnimalTest();
		test.func(new Dog());	//狗：吃	汪汪汪
		test.func(new Cat());	//猫：吃	喵喵喵
	}
	public void func(Animal animal) {//Animal animal=new dog();
		animal.eat();
		animal.sout();
	}
}
	//如果没有多态性 将会多写如下代码
//	public void func(Dog dog) {
//		dog.eat();
//		dog.sout();
//	}
//	public void func(Cat cat) {
//		cat.eat();
//		cat.sout();
//	}
//}
class Animal{
	public void eat() {
		System.out.println("动物：吃");
	}
	public void sout() {
		System.out.println("动物：叫");
	}
}
class Dog extends Animal{
	public void eat() {
		System.out.println("狗：吃");
	}
	public void sout() {
		System.out.println("汪汪汪");
	}
}
class Cat extends Animal{
	public void eat() {
		System.out.println("猫：吃");
	}
	public void sout() {
		System.out.println("喵喵喵");
	}
}

示例二：

class order{
	public void method(Object object) {
		
	}
}

多态性只适用于方法不适用于属性

public class PersonTest {
	public static void main(String[] args) {
		Person p1 =new man();
		p1.id;    //结果为：1001
                  //属性：编译和运行都只看左边
	}
}
class Person {
    int id=1001；
}
class man extend Person{
    int id=1002；
}

在多态性中，如何才能调用子类特有的属性和方法？

向下转型

Person p2 = new man();
man m1 = (man)p2;
m1.earnMoney();
m1.isSmoking=true;

但使用强制类型转换时可能出现ClassCastException的异常

因此在强制类型转换之前需要使用instanceof进行判断，避免出现异常。

instanceof：向下转型

a instanceof A:判断对象a是否是类A的实例。如果是，返回true;如果不是，返回false。
 

if (p2 instanceof woman) {
			woman w1 = (woman)p2;
			System.out.println("可以转换");
		}

代码块

1.代码块的作用:用来初始化类、对象
2.代码块只能用static来修饰

3.分类:

静态代码块

• 内部可以有输出语句
• 随着类的加载而执行,而且只执行一次
• 作用：初始化类的信息

非静态代码块

• 内部可以有输出语句
• 随着对象的创建而执行
• 每创建一个对象，就执行一次非静态代码块>
• 作用:可以在创建对象时，对对象的属性等进行初始化
   

抽象类（abstract）

abstract可以用来修饰的结构:类、方法
 

abstract修饰类:抽象类

• 此类不能实例化
• 抽象类中一定有构造器，便于子类实例化时调用（涉及。子类对象实例化的全过程)
• 开发中,都会提供抽象类的子类，让子类对象实例化，完成相关的操作
   

public class abstractTest {
    public static void main(String[] args) {
//        一旦Person类抽象了，就不可以实例化
//        Person p1 = new Person();
//        p1.eat();
    }
}
abstract class Person{
    String name;
    int age;
    public Person(){
    }
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void eat(){
        System.out.println("人吃饭");
    }
    public void walk(){
        System.out.println("人走路");
    }
}
class Student extends Person{
}

abstract修饰方法:抽象方法

• 抽象方法只有方法的声明，没有方法体

//只有方法的声明乜有方法体
public abstract void eat();

包含抽象方法的类一定是抽象类

若子类重写了父类中的所有的抽象方法后，此子类方可实例化

若子类没有重写父类中的所有的抽象方法,则此子类也是一个抽象类，需要使用abstract修饰