Day_10 面向对象多态 匿名内部类

多态(重要)

多态性 : 事物的多种形态
 
举例: 
  人类 -> 黄种人,白种人,黑种人,红种人..
  水 -> 液态水,固态冰,气态水蒸气    
  
Java基本数据类型的特性 : 自动提升和强制转换 ->  基本数据类型之间的类型转换问题!
    //byte,short,char < int < long < float < double
    
多态的本质描述的就是 : Java引用数据类型子父类之间类型转换的问题;
	//子类 < 父类 or 实现类 < 父接口
	向上转型 和 向下转型

多态的前提

1. 必须有继承或者实现关系 -> 必要条件
2. 有方法的重写 -> 不是必要条件,如果有方法重写可以看到一个现象 : 动态绑定
3. 父引用指向子类对象 -> 必要条件
	Fu 父引用 = new Zi();
	人类 人 = new 黄种人();// 只要是个黄种人就是一个人
	Animal animal = new Cat();//只要是只猫就是一只动物
	Cat cat = new Aniaml();//只要是一只动物就是一只猫 错误!!

多态下成员的访问特点

多态的前提 : 必须有继承或者实现关系

多态下成员的访问特点 和 继承关系下成员访问特点一致!
    成员变量 : 就近原则
    成员方法 : 对象是什么就调用谁的方法 -> 动态绑定
    构造方法 : 子类对象要加载优先加载父类

多态访问的弊端

    多态的弊端 :
        父引用不能访问子类的特有成员,父引用只能调用和子类共有的成员;

    为什么 : 父类/父接口根本不知道自己有这个儿子!!

多态类型之间的类型转换

多态的本质描述的就是 : Java引用数据类型子父类之间类型转换的问题;

向上转型: 自动
	父类/父接口 父引用 = new 子类();
	//以多态的形式创建的对象
向下转型: 格式
	子类型 子引用 = (子类型)父引用;

多态向下转型的弊端和解决方案

    ClassCastException: 类型转换异常

    解决办法: 提前判断,如果父引用是这个类就转,不是这个类型就不转
        1. 父引用 instanceof 类型 : 判断前面的父引用所接受的真实对象类型是否是of后面的类型 --> 返回boolean类型结果
            if(父引用 instanceof 类型){
                //向下转型
            }
        2. 父引用.getClass() -> 获取对象的字节码对象
           类名.class -> 获取类的字节码对象
           一个类只可能有一个字节码对象
           if(父引用.getClass() == 类名.class){
                //向下转型
           }

多态的使用场景

多态的使用场景:
        1. 拿父引用作为方法的形参,启动方法的方式有n+1种
            n : 此父类有多少种子类 1 : 父类自己
        2. 拿父类型作为方法的返回值类型,返回方法结果时可以有n+1种对象类型返回
        3. 拿父类型作为容器的数据类型,容器中的数据类型就可以是n+1种
            Object[] objs = new Object[10];
            ArrayList<Object> list = new ArrayList<Object>();

成员内部类(了解)

定义在类中方法外的类叫成员内部类;

格式:
    public class Outer{
		//成员位置
        public class Inner{
            
        }
    }

当一个类成为了另一个类的成员,那么这个类具备类的特点也具备成员的特点

    成员内部类中的访问问题:
        1. 在内部类中访问成员:
            a. 可以直接调用外部类的成员变量
            b. 可以直接调用自己类的成员变量
            c. 如果调用内外部类的同名变量,优先调自己类的 -> 就近原则
            d. 如果强制访问外部类成员位置的同名变量 : Outer.this.num
            e. 如果直接调用内外部同名方法,优先调用的是内部类的方法
            f. 如果强制访问外部类成员位置的同名方法 : Outer.this.方法名(实参);
        2. 在第三方类中访问内部类成员 :
                必须要创建成员内部类的对象:
                     Outer.Inner inner = new Outer().new Inner();

静态成员内部类(了解)

定义在类中方法外的类且被static修饰叫静态成员内部类;

格式:
    public class Outer{
		//成员位置
        //静态成员内部类
        public static class Inner{
            
        }
    }

 静态成员内部类访问问题:
        1. 在静态成员内部类中访问成员:
            static只能访问static! -> 生命周期!
            static中不可以有this
            a. 静态成员内部类中只能访问外部类中静态成员
            b. 静态成员内部类中强制访问外部类的同名静态成员时,只需要用外部类的类名.静态成员即可
                    外部类类名.静态成员;
       2. 在第三方类中访问静态成员内部类的成员: 还是要现有Inner对象
            Outer.Inner inner = new Outer.Inner();

局部内部类(了解)

局部内部类 : 定义在方法内的类 

格式:
    public class Outer{
        //类中成员方法
        public 返回值类型 方法名(形参){
            int num = 10;
            //局部内部类
			class Inner{
                
            }
        }
    }

成员内部类中的访问问题:
        1. 在内部类中访问成员:
            a. 可以直接调用外部类的成员变量
            b. 可以直接调用自己类的成员变量
            c. 如果调用内外部类的同名变量,优先调自己类的 -> 就近原则
            d. 如果强制访问外部类成员位置的同名变量 : Outer.this.num
            e. 如果直接调用内外部同名方法,优先调用的是内部类的方法
            f. 如果强制访问外部类成员位置的同名方法 : Outer.this.方法名(实参);
        2. 在第三方类中访问内部类成员 :
                必须要创建成员内部类的对象:
                     Outer.Inner inner = new Outer().new Inner();

匿名对象(理解)

匿名 : 匿名信
对象 : Object obj = new Object();

匿名对象 : new Object();

匿名对象能干嘛 :  对象能干嘛匿名对象就能干嘛!!
    弊端 : 匿名对象不可以重复使用!!
    什么时候用匿名 : 只是用一次的时候就可以使用匿名操作!!    

匿名内部类(重要)

匿名内部类 : 匿名内部类匿掉的是内部类的类名;

当一个类的子类/一个抽象类的子类/一个接口的实现类只使用一次,那么我们没有必要专门准备一个java文件在存储子类内容,我们可以使用 匿名内部类简化代码!!
    //匿名内部类就是对象 类/抽象类/接口 使用的一种简化格式!!
    
格式:
	//整体格式 是在创建一个不知子类名称的 类/抽象类/接口的  子类对象
    new 父类/抽象类/接口 (){
		//子类/实现类的类主体
    };

权限修饰符(理解)

权限修饰符 : 
	private < 不写 < protected < public
        
    public : 公开的
    protected : 受保护的
    不写 : 默认的
    private : 私有的

	同一个类	同一个包不同类	不同包有继承关系的类	不同包
private	√
不写	√	√
protected	√	√	√
public	√	√	√	√

可变参数(掌握)

可变参数 :  方法形参的定义方式

如果方法的形参是可变参数,那么调用方法的时候可以传入任意个此类型的实际参数

格式:
    方法的声明(数据类型...变量名) -> 定义了可变参数

    可变参数的本质就是数组!

    可变参数使用注意事项:
        1. 在可变参数的后面不可以再有其他任意类型的形参
        2. 在可变参数的前面可以有任意类型个数的形参

构造代码块(理解)

构造代码块 : 定义在类中方法外的大括号

   构造代码块的执行流程:
        每调用一次构造方法,构造代码块执行一次
        每一次构造代码块是优先于构造方法执行
        
    构造代码块的作用 : 为对象的创建做准备     
        举例 : 对象比作皇帝 构造代码块比作比皇帝先出来的宫女,太监们...

静态代码块(理解)

 静态代码块 : 定义在类中方法外且被static修饰的代码块

    格式:
        static{

        }

    执行流程:
        在类第一次加载的时候执行且只执行一次!!
        
    作用: 为类的加载做准备
        举例: 类加载的驱动!
            
 局部代码块: 约束引用的生命周期的,用来节约内存空间! -> 现在不用!