成员内部类，静态内部类，匿名内部类，局部内部类

定义：将一个类定义在另一个类的内部。内部的类称为内部类;

public class Outer{

           class inner{

         //省略

}

}

 

特点：

①   内部类可以很好的实现隐藏，可以使用protected,private修饰符;

②   内部类可以直接访问外部类的所有成员，包括私有成员;

③   外部类不能直接访问内部类的成员，必须首先要建立内部类的对象才能访问;

④   内部类可以解决一些问题，比如间接的去实现多继承。可以避免修改接口而实现同一个类中两种同名方法的调用;

 

成员内部类及应用

成员内部类特点：

①   成员内部类属于外部类的实例成员，成员内部类都可以有public,private,default,protected权限修饰符。在成员内部类中访问外部类的成员方法和属性，要使用“外部类名.this.成员方法”和“外部类名.this.成员属性”的形式;

②   创建成员内部类的实例使用“外部类名.内部类名.实例名=外部类实例名. new 内部类构造方法(参数)”的形式;

成员内部类有以下限制

①   成员内部类不能与外部类重名;

②   不能在成员内部类中定义static属性、方法和类(static,final形式的常量定义除外)。因为一个成员内部类实例必然与一个外部类实例关联，static成员完全可移到其外部类中去;

public class MemberInnerClass{
    public static void main(String []args){
        //创建外部类对象
        Outer1 outer=new Outer1();
        //创建内部类对象
        Outer1.Inner1 inner=outer.new Inner1();
        inner.innerShow();
        
        System.out.println("--------------外部类访问内部类对象--------------");
        outer.outerShow();
    }
}

class Outer1{
    private String name="张三";
    private int num1=10;
    public void outerShow(){
        System.out.println(name);
        System.out.println(num1);
        //System.out.println(num2);//外部类不能直接访问内部类的成员
        
        //外部类访问内部类对象
        Inner1 inner =new Inner1();
        inner.innerShow();
    }
    
    //当内部类改成私有时private，仅能在外部类中访问
    public class Inner1{
        private String name="李四";
        private int num2=20;
        private static final int num3=30;//静态常量在内部类中是可以使用的
        //private static int num3=30;//在成员内部类中不能声明静态成员和静态方法
        public void innerShow(){
            System.out.println(name);
            System.out.println(num2);
            
            //成员内部类可以直接访问外部类的属性和方法，包括私有的
            System.out.println("--------------");
            //外部类访问内部类时注释outerShow()，避免死循环
            //outerShow();
            
            //打印外部类中成员属性
            System.out.println("--------------打印外部类中成员属性--------------");
            System.out.println(Outer1.this.name);
            System.out.println(Outer1.this.num1);
        }
    }
}

用内部类间接实现多继承

public class MultiExtendsDemo{
    public static void main(String []args){
        C c=new C();
        //间接实现多继承
        c.showA();
        c.showB();
    }
}

class A{
    public void showA(){
        System.out.println("A");
    }
}

class B{
    public void showB(){
        System.out.println("B");
    }
}

class C{
    private class A1 extends A{
        public void showA(){
            super.showA();
        }
    }
    
    private class B1 extends B{
        public void showB(){
            super.showB();
        }
    }
    
    public void showA(){
        new A1().showA();
    }
    
    public void showB(){
        new B1().showB();
    }
}

父类中和接口中的方法名相同

为了不更改其方法且要实现这个2个方法

采用内部类的方式来实现

public class Demo2{
    public static void main(String []args){
        Son son=new Son();
        son.show();
        son.show2();
    }
}

abstract class Parent{
    public abstract void show();
}

interface IShow{
    public abstract void show();
}

/*class Son extends Parent implements IShow{
    public void show(){
        
    }
    public void show1(){
        
    }
}*/

//因为父类中和接口中的方法名相同
//为了不更改其方法且要实现这个2个方法
//采用内部类的方式来实现
//但最好的方式还是改方法
class Son extends Parent{
    public void show(){
        System.out.println("抽象类中的show方法");
    }
    
    private class Inner2 implements IShow{
        public void show(){
            System.out.println("接口中的show方法");
        }
    }
    
    public void show2(){
        Inner2 inner=new Inner2();
        inner.show();
    }
}

 

静态内部类及其应用

静态内部类特点：

①   使用static修饰的成员内部类叫静态内部类;

②   静态内部类跟外部类没有任何关系，只是在生成类名和类定义时有影响。静态内部类可以看作是与外部类平级的类。使用方式与外部类平级的类完全相同;

③   创建静态内部类的实例使用  外部类名.内部类名. 实例名=new 外部类名.内部类名(参数);

静态内部类有以下限制：

①   静态内部类的名字不能与外部相同;

②   静态内部类不能访问外部类的非静态的属性和方法，外部类不能访问内部类的非静态的属性和方法;

public class StaticInnerClass{
    public static void main(String []args){
        Outer2.Inner2 inner=new Outer2.Inner2();//构造一个静态内部类对象
        inner.innerShow();
        
        Outer2 outer=new Outer2();
        outer.outerShow();
    }
}

class Outer2{
    private String name="张三";
    private int num1=10;
    private static int num3=100;
    public void outerShow(){
        System.out.println(name);
        System.out.println(num1);
        
        //System.out.println(Inner2.name);
        Inner2 inner =new Inner2();
        System.out.println(inner.name);//访问非静态
        
        System.out.println(Inner2.num3);//访问静态
    }
    
    public static class Inner2{
        private String name="李四";
        private int num2=20;
        private static final int num3=30;
        
        public void innerShow(){
            System.out.println(name);
            System.out.println(num2);
            
            //System.out.println(Outer2.this.name);//静态内部类不能访问外部类的非静态成员
            System.out.println(Outer2.num3);
            System.out.println(num2);
        }
    }
}

 

匿名内部类及应用

匿名内部类特点：

①   匿名内部类时没有名称的内部类，没办法引用它们。必须在创建时，作为new语句的一部分来声明并创建它们的实例;

②   匿名内部类必须继承一个类（抽象的，非抽象的都可以）或者实现一个接口。如果父类（或父接口）是抽象类，则匿名内部类必须实现其所有抽象方法;

③   匿名内部类中可以定义代码块，用于实例的初始化，但是不能定义静态代码块;

匿名内部类的语法：new interface/superclass(){//类体}

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

不使用匿名内部类时

public class AnonymousInnerClass{
    public static void main(String []args){
        Person person=new Person();
        Animal dog=new Dog();
        person.feed(dog);
    }
}

abstract class Animal{
    public abstract void eat();
}

class Person{
    public void feed(Animal animal){
        animal.eat();
    }
}

class Dog extends Animal{
    public void eat(){
        System.out.println("啃骨头");
    }
}

使用匿名内部类

public class AnonymousInnerClass{
    public static void main(String []args){
        Person person=new Person();
        //Animal dog=new Dog();
        //person.feed(dog);
        
        /*Animal dog=*/new IAnimal(){
            private String name="aa";
            
            //代码块
            {
                name="哈哈";
            }
            
            //不能使用静态代码块
            //static{}
            public void eat(){
                System.out.println("啃骨头");
            }
            public void show(){
                System.out.println(name);
            }
        }.show();//调用内部的show();
        
        //person.feed(dog);
        //dog.show();//这里不能调用定义的show();
        //person.feed(dog);
        person.feed(new IAnimal(){
            public void eat(){
                System.out.println("吃鱼");
            }
        });
    }
}

//抽象类
//使用接口时先注释
//并修改Person类中的Animal为IAnimal
/*abstract class Animal{
    public abstract void eat();
}*/

//接口
interface IAnimal{
    public abstract void eat();
}

class Person{
    public void feed(IAnimal animal){
        animal.eat();
    }
}

/*class Dog extends Animal{
    public void eat(){
        System.out.println("啃骨头");
    }
}*/

局部内部类及应用

局部内部类的特点：

①   定义在代码块、方法体内的类叫局部内部类;

②   局部内部类访问外部类的属性和方法使用“外部类名.this.属性名”和“外部类名.this.方法名(参数)”的形式;

③   对外部世界完全隐藏，只能在其作用域内生成对象;

 

局部内部类有以下限制：

①   局部内部类不能加访问修饰符，因为它们不能类成员;

②   成员内部类不能与外部类重名;

③   局部内部类访问作用域内的局部变量，该局部变量需要使用final修饰;

public class LocalInnerClass{
    public static void main(String []args){
        Outer3 outer=new Outer3();
        outer.showOuter();
    }
}

class Outer3{
    private String name="张三";
    private int num1=10;
    private static int num2=20;
    public void showOuter(){
        /*final*/ int num4=50;//这里加不加final都可以被内部类访问？希望看到的且知道的帮我解答下
        //局部内部类不能加访问修饰符
        class Inner3{
            private int num3=30;
            private int num1=20;
            public void showInner(){
                System.out.println(num3);
                System.out.println(num1);
                
                System.out.println(Outer3.this.num1);
                System.out.println(Outer3.num2);
                
                System.out.println(num4);
            }
        }
        Inner3 inner=new Inner3();
        inner.showInner();
    }
}