精华内容
下载资源
问答
  • 静态内部类

    2019-06-05 19:35:56
    静态内部类 1.静态内部类可以定义静态的内容可以定义成员的内容 2.在静态内部类中使用外部类中的非静态的内容,要通过外部类的对象去使用 3.在外部类中可以通过类名使用静态内部类中的静态内容,需要通过对象使用静态...

    静态内部类

    • 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();
    		
    
    	}
    }
    
    展开全文
  • 静态内部类 总结:静态内部类可以直接调用外部类的静态方法和变量,非静态不能直接访问,要通过外部类的实例对象来访问 静态内部类的使用要点: 当一个静态内部类对象存在,并不一定存在对应的外部类对象。因此,...

    静态内部类

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

    1. 当一个静态内部类对象存在,并不一定存在对应的外部类对象。因此,静态内部类的实例方法不能直接访问外部类的实例方法。
    2. 静态内部类看作外部类的一个静态成员。一次,外部类的方法中可以通过:静态内部类.名字访问静态内部类的静态成员。通过new静态内部类()访问静态内部类的实例。
      实例:
      在这里插入图片描述

    非静态内部类

    总结:非静态内部类可以调用外部类的所有方法
    注意点:

    1. 非静态的内部类里面不能有静态的变量和方法
    2. 静态成员不能访问非静态成员:外部类的静态方法、静态代码块不能访问非静态内部类,包括不能使用非静态内部类定义变量、创建实例。
    3. 非静态内部类可以使用外部类的成员,但是外部类不能直接访问非静态内部类成员。
      概念:非静态内部类必须寄存一个外部类对象里。因此,如果有一个非静态内部类对象那么一定存在相应的外部类对象。非静态内部类对象单独属于外部类的某个对象。

    成员变量访问要点:

    1. 内部类里方法的局部变量:变量名。
    2. 内部类属性:this.变量名
    3. 外部类属性:外部类名.this.变量名。

    内部类:通过外部类来实例
    在这里插入图片描述

    内部类调用外部类的属性
    在这里插入图片描述
    作者:吴耀存
    日期:2019-5-7

    展开全文
  • 一、非静态内部类(外部类里面使用非静态内部和平时使用其他类没什么不同) 1.非静态内部必须寄存在一个外部类对象里,因此,如果有一个非静态内部类对象,那么一定存在对应的外部类对象。非静态内部类对象单独属于...

    一、非静态内部类(外部类里面使用非静态内部和平时使用其他类没什么不同)
    1.非静态内部必须寄存在一个外部类对象里,因此,如果有一个非静态内部类对象,那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象
    2、非静态内部类可以直接访问外部类成员,但是外部类不能直接访问非静态内部类成员
    3、非静态内部类不能有静态方法、静态属性和静态初始化块。
    4、外部类的静态方法、静态代码块不能访问非静态内部类,包括不能使用非静态内部类定义变量、创建实例。
    5、成员变量访问要点:

    • 内部类里方法的局部变量:变量名。
    • 内部类属性:this.变量名
    • 外部类属性:外部类名.this.变量名
      在这里插入图片描述

    二、静态内部类
    1、当一个静态内部类对象存在,并不一定存在对应的外部类对象。因此,静态内部类的实例方法不能直接访问外部类的实例方法。
    2、静态内部类看做外部类的一个静态成员。因此,外部类的方法中可以通过:"静态内部类.名字"的方式访问静态内部类的静态成员,通过new静态内部类()访问静态内部类的实例。

    三、匿名内部类
    适合那种只需要使用一次的的类。比如:键盘监听操作等等。

    注意
    1、匿名内部类没有访问修饰符
    2、匿名内部类没有构造方法。因为它边名字都没有那何来的构造方法呢。

    展开全文
  • 静态内部类可以有静态成员(方法,属性),而非静态内部类则不能有静态成员(方法,属性)。 * 2.静态内部类只能够访问外部类的静态成员,而非静态内部类则可以访问外部类的所有成员(方法,属性)。 */ public class ...
    //嵌套类分为静态嵌套类和内部类  内部类的其余两种形式:局部类 匿名内部类
    // 外部类   内部类使“多重继承”的解决方案变得更加完整。
    /* 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修饰

     

    展开全文
  • 静态内部类 1. 静态内部类只能访问外部类的静态成员 (包括静态变量、静态方法) 2. 创建静态内部类对象时,无需创建外部类对象。 3. 静态内部类可以有静态成员、也可以有非静态成员 4. 外部类访问静态内部类的非...
  • 静态内部类和非静态内部类的区别: 1. 静态内部类不持有外部类的引用 在普通内部类中,可以直接访问外部类的属性、方法,即使是private类型也可以,这是因为普通内部类持有外部类的引用,可以自由访问。而静态内部类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,743
精华内容 9,497
关键字:

静态内部类