静态内部类

1.静态内部类可以定义静态的内容可以定义成员的内容
2.在静态内部类中使用外部类中的非静态的内容,要通过外部类的对象去使用
3.在外部类中可以通过类名使用静态内部类中的静态内容,需要通过对象使用静态内部类中的成员内容
4.在其他类中可以通过外部类名.静态内部类名.静态内容使用静态内部类中的静态内容

new 外部类.静态内容类() 创建静态内部类的对象使用静态内部类中的成员

//=========================================================
//测试静态内部类
public class StaticIn {
	public static void main(String[] args) {
		
// 外部类 调用 静态内部类 中的静态内容 可以通过类名调用
		System.out.println(AA.b);
		AA.printB();
		// 外部类 调用 静态内部类 中的 成员内容 只能通过对象调用
		AA aa = new AA();
		System.out.println(aa.a);
		aa.printA();
	}
	void W(){
		System.out.println("这里是外部类的成员方法");
	}
	// 外部类 非静态
		String a = "这里是外部类的成员变量";
//==========================================================
	// 静态内部类
	static class AA {
		// 可以定义成员内容
		String a = "静态内部类,非静态变量";
		// 可以定义静态内容
		static String b = "静态内部类,静态变量";
		// 静态内部类,非静态方法
		void printA() {
			System.out.println("静态内部类,非静态方法");
		}
		// 静态内部类,非静态方法
		static void printB() {
			System.out.println("静态内部类,静态方法");
			//静态内部类调用 外部类的成员 通过对象调用
			StaticIn staticin = new StaticIn();
			staticin.W();
			System.out.println(staticin.a);
		}
		
	}
}
//============================================================	
//其他类
class Q{
// 外部类的成员方法
	void print() {
		int a = 5;
		int b = 6;
		System.out.println(a);
		System.out.println(b);
		// 其他类 调用 静态内部类静态内容 ---外部类名.静态内部类名.静态内容
		System.out.println(StaticIn.AA.b);
		StaticIn.AA.printB();
		// 其他类 调用 静态内部类成员内容 ---new外部类名.静态内部类名.静态内容
		System.out.println(new StaticIn.AA().a);
		new StaticIn.AA().printB();
		

	}
}

静态内部类
总结：静态内部类可以直接调用外部类的静态方法和变量，非静态不能直接访问，要通过外部类的实例对象来访问

静态内部类的使用要点：

当一个静态内部类对象存在，并不一定存在对应的外部类对象。因此，静态内部类的实例方法不能直接访问外部类的实例方法。
静态内部类看作外部类的一个静态成员。一次，外部类的方法中可以通过：静态内部类.名字访问静态内部类的静态成员。通过new静态内部类（）访问静态内部类的实例。

实例：



非静态内部类
总结：非静态内部类可以调用外部类的所有方法

注意点：

非静态的内部类里面不能有静态的变量和方法
静态成员不能访问非静态成员：外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例。
非静态内部类可以使用外部类的成员，但是外部类不能直接访问非静态内部类成员。

概念：非静态内部类必须寄存一个外部类对象里。因此，如果有一个非静态内部类对象那么一定存在相应的外部类对象。非静态内部类对象单独属于外部类的某个对象。

成员变量访问要点：

内部类里方法的局部变量：变量名。
内部类属性：this.变量名
外部类属性：外部类名.this.变量名。

内部类：通过外部类来实例


内部类调用外部类的属性



作者：吴耀存

日期：2019-5-7

一、非静态内部类（外部类里面使用非静态内部和平时使用其他类没什么不同）

1.非静态内部必须寄存在一个外部类对象里，因此，如果有一个非静态内部类对象，那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象

2、非静态内部类可以直接访问外部类成员，但是外部类不能直接访问非静态内部类成员

3、非静态内部类不能有静态方法、静态属性和静态初始化块。

4、外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例。

5、成员变量访问要点：

内部类里方法的局部变量：变量名。
内部类属性：this.变量名
外部类属性：外部类名.this.变量名



二、静态内部类

1、当一个静态内部类对象存在，并不一定存在对应的外部类对象。因此，静态内部类的实例方法不能直接访问外部类的实例方法。

2、静态内部类看做外部类的一个静态成员。因此，外部类的方法中可以通过："静态内部类.名字"的方式访问静态内部类的静态成员，通过new静态内部类（）访问静态内部类的实例。


三、匿名内部类

适合那种只需要使用一次的的类。比如：键盘监听操作等等。
注意

1、匿名内部类没有访问修饰符

2、匿名内部类没有构造方法。因为它边名字都没有那何来的构造方法呢。

//嵌套类分为静态嵌套类和内部类  内部类的其余两种形式：局部类 匿名内部类
// 外部类   内部类使“多重继承”的解决方案变得更加完整。
/* 1.静态内部类可以有静态成员(方法，属性)，而非静态内部类则不能有静态成员(方法，属性)。
 * 2.静态内部类只能够访问外部类的静态成员,而非静态内部类则可以访问外部类的所有成员(方法，属性)。
 */
public class CloneTest01 {
    private String a;
    private  static String b;
    private static void outPrint(){}
    private  void outPrint2(){}

    public static void main(String[] args) {
// 3、静态类和方法只属于类本身，并不属于该类的对象，更不属于其他外部类的对象。
        CloneTest01 ct=new CloneTest01();
       //4.1、非静态内部类的实例化: 外部类实例.new  内部类
        Person p=ct.new Person();
       //4.2、静态内部类可以直接实例化  它属于外部类类的，不是外部类实例的
        Student s=new Student();
        class LocalClass{
            private String a;
            public void print(){
                //5、访问方法的局部变量时，变量要加上final修饰
                System.out.println("局部内部类");
            }
        }
        new Runnable(){
            @Override
            public void run() {
                System.out.println("匿名内部类");
            }
        };
    }
      //非静态内部类
      class Person implements Cloneable,Serializable{
// 非静态内部类则不能有静态成员(方法，属性)。
       // private static String name;  //会报错
        private int age;
        public void printA(){
//            可以访问外部类的所有成员(方法，属性)
            System.out.println(a+b);
            outPrint();
            outPrint2();
        }
//        public static void printb(){}   //会报错
    }
    //静态内部类
   static class Student implements Runnable{
 // 静态内部类可以有静态成员(方法，属性)
       private static String name;
       private int age;
       public void printA(){}
       public static void printb(){
           //只能够访问外部类的静态成员(方法，属性)
           System.out.println(b);
           outPrint();
       }
        @Override
        public void run() {
            System.out.println(this.age);
        }
    }

}

 总结：

1.静态内部类可以有静态成员(方法，属性)，而非静态内部类则不能有静态成员(方法，属性)。

2.静态内部类只能够访问外部类的静态成员(方法，属性),而非静态内部类则可以访问外部类的所有成员(方法，属性)。

3.静态类和方法只属于类本身，并不属于该类的对象，更不属于其他外部类的对象。

//4.1、非静态内部类的实例化: 外部类实例.new  内部类
        CloneTest01 ct=new CloneTest01();
        Person p=ct.new Person();
       //4.2、静态内部类可以直接实例化  它属于外部类类的，不是外部类实例的
        Student s=new Student();

5、匿名内部类和局部内部类中，访问方法的局部变量时，变量要加上final修饰