Java学习之内部类

示例1：

package com.swust.面向对象;

class Person1{
    private String username="zhangsan";
    public Person1(){
        System.out.println("Person created......");
    }
    public String name ="";
    class Student{
        public Student(){
            System.out.println("Student created......");
        }
        public String username="lisi";
        public void show(){
            System.out.println(this.getClass().getName());
            System.out.println(username);
        }
    }
}

class Person2{
    private static String username = "lisi";
    static class Student{
        public void show(){
            System.out.println(username);
        }
    }
}

class Person3{
    private static String useranme="wangwu";
    static class Student{
        public  static void show(){
            System.out.println(useranme);
        }
    }
}

public class Example2{
    public static void main(String[] args) {
//       43 //        person.show();
//        //内部类为静态类
//        Person2.Student person2 = new Person2.Student();
//        person2.show();
//       由于内部类持有外部类的引用，因而可以访问外部类的成员变量50 //        Person3.Student.show();
        了
        Person1.Student person = new Person1().new Student();
        person.show();
    }
}

对于内部类的访问分为如下情况：

（1）普通情况下，访问内部类必须如下格式 : Person1.Student person = new Person1().new Student();

（2）内部类的方法为静态方法，Person3.Student person3 = new Person3.Student();

（3  局部内部类无法访问方法中的普通变量，将该变量设置为final，常量类型，由于方法调用结束的时候所要调用的参数就消失了，而对该参数添加final修饰符修饰后就变成常量，存储位置发生变化，存储在常量池中

示例2：

package com.swust.面向对象;
abstract class Base{
    public abstract void show();
}


class Student{
    private static int age = 4;
    public static void show(){
        new Base(){
            @Override
            public void show() {
                System.out.println("匿名内部类……"+age);    
            }    
        }.show();;
    }
}
public class Example4 {
    public static void main(String[] args) {
        Student.show();
    }
}

匿名内部类:内部类的简写形式，其实就是一个匿名子类对象，但是有前提，就是该内部类必须实现继承外部类或者实现一个接口

new Base(){
    @Override
    public void show() {
        System.out.println("匿名内部类……"+age);    
    }    
}
            

整条语句相当于创建一个匿名内部类的对象

示例3：

interface People{
    void show1();
    void show2();
}

class Example{
    public void show(){
        new People(){
            public void show1(){
                System.out.println("show1 execute……");
            }
            public void show2(){
                System.out.println("show2 execute……");
            }
        }.show1();
        new People(){
            public void show1(){
                System.out.println("show1 execute……");
            }
            public void show2(){
                System.out.println("show2 execute……");
            }
        }.show2();
    }
}

public class Example5 {
    public static void main(String[] args) {
        Example example = new Example();
        example.show();
    }
}

匿名内部类的使用场景：当函数参数是接口类型的时候，而且接口中的方法不超过三个，这时候可以利用匿名内部类作为实际参数进行传递

示例4：

package com.swust.面向对象;

class Dog{
    public void show(){
        new Object(){
            public void show(){
                System.out.println("匿名内部类执行……");
            }
        }.show();;
    }
    
    public void message(){
        Object object = new Object(){
            public void show(){
                System.out.println("匿名内部类执行………………");
            }
        };
    }
}


public class Example6 {
    public static void main(String[] args) {
        new Dog().show();
    }
} 

在这里不能执行：object.show()语句，由于上面语句类似于将匿名内部类子类对象进行向上转型，转换为Object对象，而Object对象中没有show方法