24Java面向对象---多态、内部类

多态

1.意义

• 同一类型的引用指向不同的对象时，有不同的实现
• 同一对象被造型为不同类型时，有不同的功能

2.向上造型

• 父类型的引用指向子类的对象
• 能造型的类型有：父类型、实现的接口
• 能点（.）出来什么，看引用的类型
  能点出来的东西少于或等于子类

3.强制类型转换成功的条件

• 引用所指向的对象，就是该类型
• 引用所指向的对象，实现了该接口

4.通过instanceof来判断引用是否是某种类型

• instanceof返回boolean结果
• 强转成功的条件就是它为true的条件

Aoo o1=new Boo();//向上造型
Boo o2=(Boo)o1;//符合条件一
Inter o3=(Inter 1)o1;//符合条件二
Coo o4=(Coo)o1;//ClassCastException类型转换异常

if(o1 instanceof Coo){
    Coo o4=(Coo)o1;//语法正确，编译错误
}
interface Inter1{
    
}
class Aoo{
    
}
class Boo extends Aoo implements Inter1{
    
}
class Coo extends Aoo{
    
}
System.out.println(o1 instance Boo);//true
System.out.println(o1 instance Inter1);//true
System.out.println(o1 instance Coo);//false

内部类

1.成员内部类

• 类中套类，外面的叫外部类，里面的叫内部类
• 内部类通常只服务于外部类，对外不具备可见性
• 内部类通常咋在外部类中创建的
• 内部类中可以直接访问外部类的成员（包括私有的）
  内部类中有个隐式的引用

class Test{
    void show(){
        Aoo o1=new Aoo();
        Boo o2=new Boo();//编译错误
    }
}
class Aoo{//外部类
    private int a;
    void(){
        Boo o=new Boo();//正确
    }
    class Boo{//内部类----Aoo的一个成员（不是独立的）
        void test(){
            System.out.println(a);//正确
            System.out.println(Aoo.this.a);//正确
             System.out.println(this.a);//错误
        }
    }
}

2.匿名内部类

• 如果在一段程序中需要创建一个类的对象（通常这个类需要实现某个接口或者继承某个类），而且对象创建后，这个类的价值也就不存在了，这个类可以不用命名，称之为匿名内部类
• 在匿名内部类中访问外部的数据，该数据必须加final
• 内部类有独立的.class

package oo.day06;
//匿名内部类演示
public class NstInnerClassDemo {
	public static void main(String[] args) {
		//错误，创建IInter1对象
		//IInter1 o = new IInter1();
		
		//正确，创建IInter1的实现类对象
		IInter1 o = new IInter1(){
			//实现类的类体(变量和方法)
		};
		//错误，实现类类体中未重写抽象方法
		//IInter2 o2 = new IInter2(){};
		
		//正确，创建实现类的对象，名为o2
		//创建了Inter2的一个子类，没有名字
		//为该子类创建了一个对象，引用叫o2
		//大括号中的为子类的类体
		int num=5;
		IInter2 o2 = new IInter2(){
			public void show(){
				System.out.println("HiHiHi");
				System.out.println(num);
			}
		};
		//通过对象调用show()方法
		o2.show();
	}
}
interface IInter1{
}
interface IInter2{
	void show();
}

3.局部内部类

• 局部内部类也叫方法内部类，就是定义在某个局部范围中的类，它和局部变量一样，都是在方法中定义的，其有效范围只限于方法 内部
• 在局部内部类中，局部内部类可以访问外部类的所有成员变量和方法，而局部内部类中的变量和方法却只能在创建该局部类的方法中进行访问

//定义外部类
class Outer{
    int m=0;
    void test1(){
        System.out.println("外部类成员方法");
    }
    void test2(){
        //1.定义局部内部类Inner，在局部内部类中访问外部类变量和方法
        class Inner{
            int n=1;
            void show(){
                System.out.println("外部类变量m="+m);
                test1();
            }
        }
        //在创建局部类的方法中，调用局部内部类变量和方法
        Inner inner = new Inner();
        System.out.println("局部内部类变量n="+inner.n);
    }
}
//定义测试类
public class Test{
    public static void main (String [] args){
        Outer outer=new Outer();
        outer.test2();//通过外部类对象调用创建了局部内类的方法
    }
}

4.静态内部类

• 所谓静态内部类，就是使用static关键字修饰的成员内部类。与成员内部类相比，在形式上，静态内部类只是在内部类前增加了static关键字，但在功能上，静态内部类中只能访问外部类的静态成员，同时通过外部类访问静态内部类成员时，可以跳过外部类从而直接通过内部类访问静态内部类成员
• 创建静态内部类对象的基本语法格式如下：
  外部类名.静态内部类名 变量名=new 外部类名.静态内部类名

//定义外部类Outer
class Outer {
    static int m=0;//定义外部类静态变量m
    static class Inner {
        void show(){
            //静态内部类访问外部类静态成员
            System.out.println("外部类静态变量 m="+m);
        }
    }
}
//定义测试类
public class Test{
    public static void main (String [] args){
        //静态内部类可以直接通过外部类创建
       Outer.Inner inner=new Outer.Inner();
       inner.show();
    }
}