内部类介绍

一、内部类

    ①局部内部类:定义在一个类方法中的类；

    作用:对于当前的show方法来说,相当于将他的一部分功能面向对象了形成了局部内部类,即保证了代码的私有     化,又实现了对代码的整理,增加代码的可读性，简化了代码,增加了复用性.

    作用的范围:从定义当前的局部内部类开始到所在的方法结束.

    final:被final修饰的变量会被放在常量区,而常量区的值存在的时间要大于局部变量所在的方法,相当于从原来       的基础上扩大了作用域

    ②匿名内部类(对象):定义在一个类方法中的匿名子类对象，属于局部内部类. 

       创建匿名内部类的前提:
             * 1.匿名内部类必须有父类或父接口
             * 注意点:匿名子类对象就是父类或父接口的子类对象

       内部类的作用:
             * 1.间接实现了多继承
             * 2.方便定义
             * 3.只有外部类可以访问创建的内部类的属性和方法,包括私有方法
             * 4.同一个包中其他的类不可见,有了很好的封装性

    创建匿名子类对象
        

public class Demo3 {
    public static void main(String[] args) {
        //创建匿名对象
//        new Test1().Test1Method();//创建匿名对象并调用方法
//        
//        //创建匿名子类对象
//        //第一种
//        //使用已有的子类生成匿名子类对象并调用方法
//        //特点:现成的子类,可以使用多次
//        new SubTest1().Test1Method();
//        //第二种:构成:new 父类/接口的名字+()+{子类的内容}
//        //直接创建没有名字的Test1类的匿名子类对象并调用方法
//        //特点:只能使用一次.
//        new Test1(){
//            public void Test1Method() {
//                  System.out.println("haha");
//            }
//        }.Test1Method();
        //给他起个名字---多态
//        Test1 test1 =  new Test1(){
//            public void Test1Method() {
//                  System.out.println("haha");
//            }
//        };
//        test1.Test1Method();
        
        //研究匿名内部类
        Outer1 outer1 = new Outer1();
        outer1.show();
        
        //匿名内部类做参数
        outer1.testCanshu1();
        outer1.testCanshu2();
        
        //匿名内部类做返回值
        String string1 =  outer1.testFanhuizhi1();
        System.out.println(string1);
        Test1 test1 =  outer1.testFanhuizhi2();//多态
//        test1.eat();  无法调用子类特有的方法
        test1.Test1Method();
    }
}

//研究匿名对象
class Test1{
    public  void Test1Method() {
        System.out.println("Test1-Test1Method");
    }
}

class SubTest1 extends Test1{
    public void Test1Method() {
        System.out.println("SubTest1-Test1Method");
    }
}

//研究匿名内部类(对象)
class Outer1{
    public void show() {
        //创建的匿名内部类对象--匿名子类对象
        new Test1(){
            //重写父类的方法
            public void Test1Method() {
                System.out.println("重写父类的方法");
            }
            
            //定义自己的方法
            public void song(){
                System.out.println("自己的方法");
            }
        }.Test1Method();
        
        new Test1(){
            //重写父类的方法
            public void Test1Method() {
                System.out.println("重写父类的方法");
            }
            
            //定义自己的方法
            public void song(){
                System.out.println("自己的方法");
            }
        }.song();
        
    }
    
    //作为参数
    //普通对象充当参数
    public void testCanshu1(){
        System.out.println(new Object());
    }
    public void testCanshu2(){
        System.out.println(new Test1(){
            public void run() {
                System.out.println("run");
            }
            //让当前的testCan2返回:一会儿该下课了
            //方法一:
//            public String toString() {
//                return "一会儿该下课了";
//            }
            
            //方法二:
            public  String jump() {
                return "一会儿该下课了";
            }    
        }.jump());
    }
    
    //作为返回值
    //普通对象充当返回值
    public String  testFanhuizhi1() {
        return new Object().toString();
    }
    //匿名内部类对象充当返回值
    public Test1 testFanhuizhi2(){
        return new Test1(){
            public void eat() {
                System.out.println("eat");
            }
        };
                
    }
    
    
    //接口对应的匿名内部类对象充当参数,返回值等---自己写
}

转载于:https://my.oschina.net/u/3174809/blog/1828382