面向对象 内部类

java

内部类概念

内部类（Inner Class）

• 所谓内部类（Inner Class），就是将一个类定义在里一个类的内部，内部的类称之为内部类

    public class Outer{
        class Inner{
                //省略
        }
    }

内部类的主要特点

• 内部类可以很好的隐藏，可以使用protected、private修饰符
• 内部类可以直接访问外部类的所有成员，包括私有的成员
  -外部类不能直接访问内部类的成员，必须首先要建立内部类的对象才可访问
  -内部类可以解决：间接地去实现多继承，可以避免修改接口而实现同一个类中俩种同名方法调用

成员内部类

成员内部类的特点

• 成员内部类属于外部类的实例成员，成员内部类可以有所有的修饰方法，在成员内部类中访问外部类的成员方法和属性，要使用外部类名.this.成员方法/成员属性的形式
• 成员内部类的实例使用：外部类名.内部类名 实例名 = 外部类实例名.new 内部类的构造方法(参数)的形式
• 内部类和外部类的属性和方法不同名时直接访问，如果同名使用外部类名.this.成员方法/属性

成员内部类有以下限制

-成员内部类不能与外部类重名
- 不能在成员内部类定义static属性、方法和类（static、final形式的常量定义除外）因为一个成员内部类实例必然与一个外部类实例**关联**static成员完全可以移到外部类中

成员内部类实例

public class MenberInnerClass {
    public static void main(String[] args) {
        // 外部类的应用
        Outer outer = new Outer();
        outer.outerShow();
        // 内部类的应用
        // 外部类名.内部类名 实例名 = 外部类实例名.new 内部类的构造方法
        Outer.Inner inner = outer.new Inner();
        inner.innerShow();
    }
}
// 外部类
//成员内部类和外部类不能同名
class Outer {
    private String name = "张三";
    private int num1 = 100;
    public void outerShow() {
        System.out.println(name);
        System.out.println(num1);
        /*外部类不可直接访问内部类的属性和方法
        System.out.println(num2);
        innerShow();*/
        //如果访问通过创建一个内部对象
        Inner inner = new Inner();
        System.out.println("要访问通过创建的一个内部对象");
        inner.innerShow();
        System.out.println("99999999999");
    }
    // 内部类
    //成员内部类可以用4种修饰符
    public class Inner {
        /*不能在成员内部类中定义static属性/方法/类
        private static int i = 300;
        public static inner(){
        }*/
        private String name = "李四";
        private int num2 = 100;
        //成员内部类访问外部类的属性方法：外部类名.this.成员方法/属性
        //内部类可以访问外部类的成员包括私有成员
        public void innerShow() {
            System.out.println(name);
            System.out.println(num2);
            System.out.println("=======");
            //内部类可以直接访问外部类的成员
            //内部类和外部类的属性和方法不同名时：直接访问，
            //如果同名使用外部类名.this.成员方法/属性
            System.err.println(Outer.this.name);//与外部类同名
            System.err.println(num1);
            outerShow();
        }
    }
}

静态内部类

静态内部类特点

• 使用static修饰的成员内部类叫做静态内部类
• 跟外部类没有任何关系，只在生成类名和类定义时有影响，与外部类平级，使用方法与外部类平级的类完全相同
• 外部类名.内部类名 实例名 = new外部类.内部类类名(参数)

静态内部类有以下限制

• 不能与外部类重名
• 不能访问外部类的非静态的属性和方法
• 外部类不能访问内部类的非静态的属性和方法

静态内部类实例

public class StaticInnerClass {
    public static void main(String[] args) {
        //外部类名.内部类名 实例名 = new外部类.内部类类名(参数)
        Outer.Inner inner = new Outer.Inner();
        inner.innerShow();
    }
}
class Outer{
    private String name = "大师兄";
    private int num1 =100;
    private static int num2 = 200;
    public void outerShow(){
        System.out.println(name);
        System.out.println(num1);
    }
    //静态内部类
    static class Inner{
        private String name = "二师兄";
        private int num3 =300;
        private static int num4 = 400;
        public void innerShow(){
            System.out.println(name);
            System.out.println(num2);
        }
    }
}

匿名内部类

匿名内部类特点

• 是没有名称的内部类，没办法引用它们，必须在创建的时候，作为new语句的一部分来声明并创建它们的实例
• 必须继承一个类（抽象的、非抽象的都可以）或者一个接口
• 如果父类（或者父接口）是抽象类，则匿名内部类必须实现其所有抽象方法
• 可以定义代码块，用于实例的初始化，但是不能定义静态代码块

匿名内部类语法

    new interface/superclass(){
       //类体
    }

• 这种形式的new语句声明一个新的匿名类，他对一个给定的类进行扩展，或者实现一个给定的接口，并同时创建该匿名类的一个新实例

匿名内部类实例

public class TestAnomousclass {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Person person = new Person();
        //Dog dog = new Dog();
        //Cat cat = new Cat();
        //狗
        person.feed(new IAnimal() {
            @Override
            public void eat() {
                // TODO Auto-generated method stub
                System.out.println("Dog-----肉");
            }
        });
        //猫000000000000
        person.feed(new IAnimal() {
            @Override
            public void eat() {
                // TODO Auto-generated method stub
                System.out.println("Cat-----鱼");
            }
        });
    }
}
class Person {
    public void feed(IAnimal animal) {
        animal.eat();
    }
}
interface IAnimal {
    public abstract void eat();
}
class Dog implements IAnimal{
    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("Dog-----肉");
    }
}
class Cat implements IAnimal{
    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("Cat-----鱼");
    }
}

局部内部类

局部内部类特点

• 定义在代码块、方法体内的类叫做局部内部类
• 局部内部类访问外部类的属性和方法使用“外部类名.this.属性名”和“外部类名.this.方法名（参数）”的形式
• 对外部世界完全隐藏，只能在其作用域内生成对象

局部内部类有以下限制

• 不能加访问修饰符，因为它不是类成员
• 不能与外部类重名
• 访问作用域的局部变量，该局部变量需要使用final修饰

局部内部类实例

public class LocalInnerClass2 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerShow();
    }
}
class Outer {
    private String name = "张三";
    private int num1 = 100;
    public void outerShow() {
        int num2 = 300;
        // 局部内部类不能加访问修饰符
        class Inner {
            private String name = "李四";
            private int num3 = 400;
            public void innerShow() {
                System.out.println(name);
                System.out.println(num2);
            }
        }
        Inner inner = new Inner();
        inner.innerShow();
    }
}