面向对象-内部类

面向对象-内部类

public class Outer {//外部类
    private int num = 10;
    public class inner {//内部类
            public void printNum(){
                //内部类可以直接访问外部类的成员, 包括私有的.
                System.out.println("num="+num);
            }
    }
         public void methor(){
             inner i = new inner();
             //外部类要访问内部类的成员,必须创建对象
             i.printNum();
         }
}

public class Outer {//外部类
    private int num = 10;

    //    public class inner {//内部类
//        public void fun1() {//内部类方法
//            System.out.println(num);
//        }
//    }   但是一般情况不这样使用, 内部类一般是不让外界直接看到,
    //使用private关键字
    private class inner {//内部类
        public void fun1() {//内部类方法
            System.out.println(num);
        }
    }

    public void method() {//外部类方法
        inner i = new inner();
        i.fun1();
    }   //用外部类的对象调用这个方法,就能实现内部类成员的调用.
}
//------------------------------
//测试类
public class Demo {
    public static void main(String[] args) {
//        Outer.inner oi = new Outer().new inner();//不这样使用
            Outer outer = new Outer();
            outer.method();
    }
}

public class Outer {  //外部类
    private int a = 10;

    public void method1() {  //外部方法
        class inner {  //局部内部类
            public void fun1() {    //内部方法
                System.out.println(a);
            }
        }
        //在外部方法中创建内部类对象,调用方法
        inner inner = new inner();
        inner.fun1();
    }
}
//---------------------------------------------
//测试类
public class Demo {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method1();
        //直接调用外部方法即可
    }
}

//接口
public interface Jumpping {
    void jump();
}
//---------------------------

public class Outer {  //外部类
    public void method() {  //外部方法
        new Jumpping() {   //匿名内部类
            @Override
            public void jump() {    //重写接口的方法
                System.out.println("匿名内部类");
            }
        };  /*我的理解是 : 把创建实现类和实现接口,
              再用多态的形式创建对象的步骤省略了,
              在方法中new一个直接使用.
            */

    }
}
//------------------------------
//调用匿名内部类的方法
public class Outer {  //外部类
    public void method() {  //外部方法
        new Jumpping(){
            @Override
            public void jump() {
            }
        }.jump();
        //匿名内部类的本质是继承了该类或实现了该接口的对象, 是对象就可以".方法"      
    }
}
//--------------------------------
//调用匿名内部类的方法
public class Outer {  //外部类
    public void method() {  //外部方法
        Jumpping j = new Jumpping(){
            @Override
            public void jump() {
                System.out.println("匿名内部类");
            }
        };
        //如果要多次调用,可以使用多态的形式把它赋值为一个父类或接口类型的变量.
        j.jump();
        j.jump();
    }
}

匿名内部类的应用

//接口
public interface Jumpping {
    void jump();
}
//------------------------------
//猫
public class Cat implements Jumpping{
    @Override
    public void jump() {
        System.out.println("猫跳来跳去");
    }
}
//------------------------------
//狗
public class dog implements Jumpping{
    @Override
    public void jump() {
        System.out.println("狗跳来跳去");
    }
}

//---------------------------------------
//操作类
public class JumpOperator {
        public void method(Jumpping j){
            //形参是接口名实际上要的是接口的实现类对象
            j.jump();
        }
}
//------------------------------------
//测试类
public class Demo {
    public static void main(String[] args) {
        JumpOperator j = new JumpOperator();
        Jumpping cat = new Cat();
        j.method(cat);
        Jumpping dog = new dog();
        j.method(dog);
        /*如果还有很多的动物都要调用j.jump()方法,每一次都要创建一个类,
           然后创建对象,传递参数,太繁琐了.    这时我们可以用匿名内部类.
        */
        j.method(new Jumpping(){
            @Override
            public void jump() {
                System.out.println("xxx跳来跳去");
            }
        });//在方法形参中直接使用匿名内部类, 可以简化操作.
    }
}