day10

10.08 面向对象（内部类概述和访问特点）
 A.内部类概述
 B.内部类访问特点
　　a.内部类可以直接访问外部类的成员，包括私有（******）
　　b.外部类要访问内部类的成员，必须创建对象 （****************）
　　　　外部类名.内部类名 对象名 = 外部类对象.内部类对象
 C.案例演示

public class day10_08 {
    public static void main(String[] args) {
        Outer.Inner i = new Outer().new Inner();    //外部类名.内部类名    对象名  = 外部类对象.内部类对象
        i.method();
    }
}
class Outer{
    class Inner{
        public void method(){
            System.out.println("Hello World");
        }
    }
}
--------------------------------------
public class day10_08 {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();   //外部类名.内部类名   对象名 = 外部类名.内部类对象
        oi.method();
    }
}
class Outer{
    private int num = 10;        //外部类的私有成员变量
    class Inner{
        public void method(){
            System.out.println("Hello World");
            System.out.println(num);
        }
    }
}

10.09 面向对象（成员内部类私有使用）
　　private
10.10 面向对象（静态成员内部类私有）
　　1.static
　　2.成员内部类被静态修饰后的访问方式是：（********************）
　　　　外部类名.内部类名 对象名 = 外部类名.内部类对象
10.11 面向对象（成员内部类私有）

public class day10_11 {
    public static void main(String[] args) {
        Outer11 s = new Outer11();
        s.print();
    }
}
//1.将内部类进行私有
class Outer11{
    private int num = 20;        //外部类的私有成员变量
    private class Inner{
        public void method(){
            System.out.println("Hello World");
            System.out.println(num);
        }
    }
    //2.新建一个方法,并在里面创建对象
    public void print(){
        Inner i =new Inner();
        i.method();
    }
}

10.12 面向对象（局部内部类访问局部变量的问题）（****************）
　　//外部类名.内部类名 对象名 = 外部类名.内部类对象

public class day10_12 {
    public static void main(String[] args) {
        //外部类名.内部类名  对象名 = 外部类名.内部类对象
        Outer12.Inner oi = new Outer12.Inner();
        oi.method();
        //外部类名.内部类名.方法名
        Outer12.Inner2.print();
    }
}
//外部类 里面有静态内部类以及静态方法
class Outer12{
    static class Inner{
        public void method(){
            System.out.println("method");
        }
    }
    
    static class Inner2{                    //静态内部类
        public static void print(){            //静态成员方法    
            System.out.println("print");
        }
    }
}

10.13 面向对象(匿名内部类的格式和理解)
 A.匿名内部类就是内部类的简写
 B.前提:存在一个类或者接口(这里的类可以是抽象类或者接口)
 C.格式:
　　new 类名或者接口名(){
　　　　重写方法；
　　}
　　方式二：用new 接口名(){}.print() （****************）
　　　进行匿名内部类调用，有时候可以不用继承一个内部类。
 D.本质是:一个继承了该类或者实现了该接口的子类匿名对象
 E.案例演示

public class day10_13_匿名 {
    //实现接口必须重写接口的所有方法
    /*    问：内部类实现了接口，并定义了方法，如何访问到内部类里的方法？
         答：    1.在外部类中定义一个方法，并在该方法中实现内部类对象。并调用内部类方法
             2.在主方法中实现外部类对象，并调用外部类中创建了对象的方法体*/
    public static void main(String[] args) {
        Outer3 o = new Outer3();            //2.在主方法中实现外部类对象，
        o.method();                            //并调用外部类中创建了对象的方法体
    }
}

interface Inter3{
    public void print();
}

class Outer3{
    class Inner implements Inter{            //内部类实现Inter接口
        public void print(){
            System.out.println("print");    //实现接口必须重写接口的所有方法
        }
    }
    public void method(){                    //1.在外部类中定义一个方法，并在该方法中...
        //创建匿名内部类
        new Inner(){}.print();                
        
        new Inter(){                        //实现Inter接口
            public void print(){            //实现接口必然要重写抽象方法
                System.out.println("print");
            }
        }.print();
    
    }
}

//实现接口必须重写接口的所有方法
/*    问：内部类实现了接口，并定义了方法，如何访问到内部类里的方法？
     答：    1.在外部类中定义一个方法，并在该方法中实现内部类对象。并调用内部类方法
         2.在主方法中实现外部类对象，并调用外部类中创建了对象的方法体*/
public class day10_13 {
    public static void main(String[] args) {
        Outer13 o = new Outer13();            //2.在主方法中实现外部类对象，
        o.method();                            //并调用外部类中创建了对象的方法体
    }
}

interface Inter{
    public void print();
}

class Outer13{
    class Inner implements Inter{            //内部类实现Inter接口
        public void print(){
            System.out.println("print");    //实现接口必须重写接口的所有方法
        }
    }
    public void method(){                    //1.在外部类中定义一个方法，并在该方法中...
        Inner i = new Inner();                //...实现内部类对象
        i.print();                            //,并调用内部类方法
    }
}

10.14 面向对象(匿名内部类重写多个方法调用)
A.案例演示
匿名内部类的方法调用