java面向对象之多态

多态

概念: 父类的引用指向子类的实例对象
必须在继承关系的状态下产生了多态的概念

public class Person{}
public class Teacher extends Person{}
public clsss Student extends Person{}

public class Test{
	public static void main(String[] args){
		
		Teacher t = new Teacher();	
	
		Teacher t;	// 声明一个对象类型(声明了一个引用变量)
		t = new Teacher();	// 对指定的对象进行实例化
	
		int n;
		n = 1000;
	
		//  父类的引用 指向 子类的实例对象
		Person p = new Teacher();	// 多态
	
		// 声明的数据类型必须为父类类型, 而实例化的数据类型必须为子类类型
		Person p2 = new Student();
	
		Student s = new Student();
		Person p = new Person();
	
	}
}	

注意: 子类绝对不能指向父类的实例对象

向上转型 : 由本态转换为多态(父类的引用指向子类的实例对象)
向下转型: 由多态转换为本态(子类的引用指向子类实例本身),将父类类型强制转换为子类类型

---

instanceof

判断instanceof关键字前后的类型是否为同一种数据类型 - - - > 关键字前的数据类型是否与关键字后的实际对象数据类型一致

最终作用: 能够调用子类中独有成员方法(父类中不存在)
- - 注意: 必须向下转型

// 由于引用变量的数据类型是Person类型，
// 所以不能将父类的类型赋给子类的类型
Person p = new Teacher();
if(p instanceof Teacher){
	// 向下强制转换
	Teacher t = (Teacher)p;
}
        

抽象类: abstract

类: 将现实世界中某一种具体事物进行抽象描述(特征与行为)

抽象类: 将现实世界中具有相同类型的多种事物进行抽象描述

关键字: abstract 声明当前类为一个抽象类

abstract class Animal{

    private String name;
    private double weigth;

    public Animal(){}

    public Animal(String name, double weigth){
        this.name = name;
        this.weigth = weigth;
    }

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

    public double getWeigth(){ return this.weigth; }
    public double setWeigth(double weigth){ return this.weigth = weigth; }

    /*
    public void eat(){
        System.out.println("???");
    }

    public void sleep(){
        System.out.println("???");
    }*/
    public abstract void eat();
    public abstract void sleep();
}

class Dog extends Animal{

    public void eat(){
        System.out.println("够吃骨头");
    }

    public void sleep(){
        System.out.println("狗睡狗窝");
    }

    public void dogMethod(){
        System.out.println("Dog类中独有的dogMethod方法");
    }

}

class Cat extends Animal{

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

    public void sleep(){
        System.out.println("猫睡猫窝");
    }

    public void catMethod(){
        System.out.println("Cat类中独有的catMethod方法");
    }

}

可以修饰:

1. 修饰类: 被abstract修饰的类称之为抽象类

   1. 抽象类不能被实例化
      – 为什么不能被实例化?

   2. 抽象类中可以包含抽象方法

2. 修饰方法: 被abstract修饰的方法称之为抽象方法

   抽象方法只有方法声明, 而没有方法体

   语法: 访问控制修饰符 abstract 返回类型 方法名称(参数列表);

    public abstract void eat();
   

   抽象方法为什么没有方法体?
   因为它的具体实现功能在抽象类中不明确

    **注意**: 
    	如果一个子类继承了抽象父类, 
    	那么该子类必须重写抽象父类中的所有的抽象方法	
    		
    	如果一个子类继承了抽象父类,
    	但没有重写抽象父类中所有的抽象方法, 
    	那么该子类必须声明成为抽象类
   

抽象类: 1. 不能被实例话 2. 抽象类适用于多态

static

static: 静态的
可以修饰:

1. 成员属性
   被static 修饰的成员属性称之为静态变量/类属性
   – 被所有对象共享使用

2. 成员方法
   被static修饰的成员方法称之为静态方法/类方法
   被static修饰的成员的调用方式:
   类名.成员名称
   对象名.成员名称

注意: 抽象方法不能被static修饰

静态代码块:
被static修饰的代码块称之为静态代码块

static{
…
}

1. 静态代码块在类加载时被执行
   – 如果有多个静态代码块, 那么按照书写顺序执行
2. 只会被执行一次

动态代码块:

不使用static修饰的代码块

{
// code…
}

执行时机:
在实例化对象之前被执行
– 在调用构造器之前被执行.
在每次创建对象之前都会被执行

作用: 在实例化对象之前做一些初始化工作

应用程序执行:

	源码进行编译成为字节码
	将字节码加载到内存中(类加载)
	到main方法,按顺序执行