27 内部类

方法内部类,成员内部类,静态内部类，匿名内部类

1.方法内部类

public class Person{
    
    public static void main(String[] args){
        //调用内部内对象就是先---外部类对象.方法();在方法中创建内部类对象，并且通过内部类对象来调用内部类属性和方法
        
     new out().m();
    }
}
class out{
    int b=0;
    public void n() {
        final int k2=10;
        m(); //n中调用m方法
    }
    public void m() {
        int k=10;//在jdk1.7及其以前要显式的去表示这个是常量(要加上final)，就是显式常量
        //jdk1.8新特性及其以后就是隐式常量(只要定义一个变量就是常量),在方法内部类中去用的时候就是常量
        //方法内部类
        /**1.只能定义非静态的属性和方法
         * 2.final也可以修饰方法和属性
         * 3.可以定义静态常量(static final)
         * 4.可以能到外部类所有的属性和方法
         * 5.可以拿到包含此内部类方法里的常量，声明的变量在此时也会隐式的转换成常量(加上了final)
         *6.可以继承其他类和实现接口
         *7.内部类前不允许加访问修饰符 ，只能加final或者abstract(抽象)我们就无法访问到 
         *8.如何创建内部类的对象？ 不能再其他方法中创建内部类对象，只能在本方法内创建
         *9.别的方法中调用内部内对象就是先---外部类对象.方法();在方法中创建内部类对象，并且通过内部类对象来调用内部类属性和方法
         */
        
          class Inner1 extends Object {
            static final int a=2;

            void m2() {
                //可以拿到外部类的属性方法 
                System.out.println(b);
                //
                //可以拿到方法中的常量
                System.out.println(k);
                //  k=11;//这里报错了因为k是一个隐式常量,值不能被修改
                //不能拿到不包含此内部类方法 的常量
                //System.out.println(k2);
          
            }//endm2()

        }//end内部类
          //创建内部类对象
          Inner1 nei=new Inner1();
          nei.m2(); //调用内部类中的方法
    }//endm()
}//endout类

 2.成员内部类

public class Person{
    
    public static void main(String[] args){
        //创建成员内部类的对象
        Out.Inner1 in1=new Out().new Inner1();
    }
}

//外部类
 class Out{
    //属性 -----成员变量
    int i=1;
    /**
     * 位置在类内方法外
     * 1.只能定义非静态属性和方法
     * 2.可以修饰静态常量(static final)和常量
     * 3.可以拿到外部类所有的属性和方法
     * 4.和方法内部类的很大区别是可以被访问修饰符修饰
     * 5.可以继承和多实现
     * 6.如何产生对象?  通过外部类找到内部类然后声明对象就好
     */
    //成员内部类
    public class Inner1 extends Object implements Cloneable{
        //属性
         int j=2;
        //方法
        public void n() {
            
        }
        
    }//endInner1
    //方法----成员方法
    public void m() {
            
    }
}//endout类

 3.静态内部类

public class Person{
    
    public static void main(String[] args){

        System.out.println(Out.Inner1.j);//访问静态内部类中的静态属性
        //创建静态内部类的对象
        Out.Inner1 in=new Out.Inner1();
    }
}

//外部类
 class Out{
    //属性 -----成员变量
    static int i=1;
    /**
     * 位置在类内方法外
     * 1.可以定义任意的属性和方法(静态和非静态都可以)以及静态常量
     * 2.只能拿到外部内的静态属性和方法;
     * 3.可以被访问权限修饰符修饰和final和abstract
     * 4.可以继承和多实现
     * 5.如何产生对象?  通过外部类点出静态内部类然后创建内部类对象
     */
    //静态内部类
    static class Inner1 extends Object implements Cloneable{
        //属性
        static int j=2;
        int i=3;
        //方法
        public void n() {
            System.out.println(i);
        }
        
    }//endInner1
    //方法----成员方法
    public void m() {
            
    }
}//endout类

4.匿名内部类---实质继承或者实现,最终要进行方法重写。

public class Person{
 C c=new C() {//成员位置下的匿名内部类
     
 };
    public static void main(String[] args){
        /**
         * 匿名内部类
         * 1.{}匿名内部类的内容 {}相当于匿名内部类
         * 2.匿名内部类在重写重写抽象方法
         * 3.匿名内部类就是在继承类(抽象类和普通类 )
         * 4.一个类或者接口可以被继承或者实现，那么这个类或者接口就会有匿名内部类的形式
         * 5.构造函数私有化也可以被继承
         * 6.创建一次对象，创建一个匿名内部类麻烦
         * 7.如果匿名内部类在方法中定义中，就和方法内部类使用一致
         * 8.如果匿名内部类在成员的位置定义就和成员内部类使用一致
         */
        D d=new D() {

            @Override
            void m() {
                // TODO 自动生成的方法存根

            }
        };
        C c=new C() { //普通类也能有匿名内部类
            
        };
    /*B b=new B() { //final修饰的不能被继承的类没有匿名内部类
            
        };*/
    A a=new A() { //接口也能有匿名内部类
            
        };
    }
}
interface A{
    
}
final class B{
    
}
class C{
    
}
class E{
    //私有构造，感觉不能被继承，但是可以通过内部类访问
    private E () {
        
    }
    class E2 extends E{
        //通过E2成员内部类访问
    }
}
abstract class D{
    abstract void m();
}

public class Person{

    public static void main(String[] args){
        int j=10;
        A2 a=new A2() { //这个a不是接口的对象是匿名内部类的对象
            int i=10;
            @Override
            public void m() {
                //j=20;  //报错，此时的匿名内部类相当于方法内部类，使用方法中的变量的时候是隐式的添加了final
                //不可改变
                System.out.println(j);
                // TODO Auto-generated method stub

            }
        };
        a.m();
    }
}

interface A2{
    void m();
}

 

 接口中的内部类 默认用static 修饰

内部接口 ：接口中来个接口，类中再来个接口（再来个接口默认是静态的） 详情请看：https://www.cnblogs.com/chenpi/p/5518400.html