精华内容
下载资源
问答
  • 成员内部类

    2019-06-09 12:50:36
    成员内部类: 内部类定义在外部类的成员位置 成员:可以使用成员修饰符,public static … 类:可以继承类,可以实现接口 //测试成员内部类 public class TestM { public static void main(String[] args) { MumberIn ...

    成员内部类:

    内部类定义在外部类的成员位置
    成员:可以使用成员修饰符,public static …
    类:可以继承类,可以实现接口

    内部类中可以直接使用外部类中的所有的内容,包括私有的
    内部类中不可以直接定义静态的内容,除了静态的常量,静态的内容要定义在静态内部类当中

    //测试成员内部类
    public class TestM {
    	public static void main(String[] args) {
    		MumberIn name = new MumberIn();
    	name.outer();	
    	}	
    }
    
    //测试成员内部类
    public  class MumberIn {
    	//变量
    	int a = 4;
    	private int b = 3;
    	//成员内部类
    	public class Inner{ 
    		int a =2;
    		private static final int b = 3;
    		
    		public void inner(){
    			System.out.println("蔡徐坤");
    			System.out.println(a);
    			MumberIn mumberIn = new MumberIn();
    			System.out.println(mumberIn.a);
    		}		
    	}
    	public  void outer() {
    		MumberIn mumberIn = new MumberIn();
    		System.out.println(mumberIn.a);
    	//	System.out.println(mumberIn.b);
    		Inner inner = new Inner();
    		inner.inner();
    	}	
    }
    
    展开全文
  • 内部类(成员内部类、静态内部类、方法内部类)

    万次阅读 多人点赞 2018-06-05 15:33:35
    一:成员内部类:最常见的内部类就是成员内部类,也称作普通内部类;1、Inner类定义在Outer类的内部,相当于Outer类的成员变量的位置,Inner类可以使用任意访问修饰符,如:public、private、protected等。2、Inner...

    一:成员内部类:

    最常见的内部类就是成员内部类,也称作普通内部类;


    1、Inner类定义在Outer类的内部,相当于Outer类的成员变量的位置,Inner类可以使用任意访问修饰符,如:public、private、protected等。

    2、Inner类中定义的test()方法可以访问Outer类中的数据,不受访问控制符的影响。

    3、 定义了成员内部类后,必须使用外部类对象来创建内部类对象,而不能直接去 new 一个内部类对象,即:内部类 对象名 = 外部类对象.new 内部类( );如创建Inner的内部类对象:要先创建外部类对象:Outer o = new outer(); 创建内部类:Inner i = o.new Inner();访问Inner中的test()方法:i.test();

    例如:


    4、如果外部类和内部类具有相同的成员变量或方法,内部类可以直接访问内部类的成员变量或方法,但如果内部类访问外部类的成员变量或者方法时,需要使用this关键字;如下:


    二:静态内部类

    静态内部类就是用static修饰的内部类,这种内部类的特点是:

    1、静态内部类不能直接访问外部类的非静态成员,但,可以通过new 外部类().成员的方式访问;


    2、如果外部类的静态成员与内部类的静态成员相同, 可以通过"类名.静态成员"来访问外部类的静态成员;如果不同,可以直接调用外部类的静态成员名。



    3、创建静态内部类的对象时,不需要外部类的对象,可以直接创建;

    三:方法内部类:

    1、方法内部类就是定义在外部类的方法中,方法内部类只在该方法内可以用;


    2、由于方法内部类不能在外部类的方法以外的地方使用,因此方法内部类不能使用访问控制符和 static 修饰符。




    展开全文
  • java内部类之成员内部类、局部内部类和匿名内部类

    千次阅读 多人点赞 2018-07-15 16:13:30
    1、成员内部类。 2、局部内部类(包含匿名内部类)。 成员内部类 定义格式: 修饰符 class 类名称 { 修饰符 class 类名称 { //... } //... } 注意: 内部类使用外部,可以随意访问,但是外部类使用内部类...

    内部类概念

    一个类中包含另外一个类。

    分类

    1. 成员内部类。
    2. 局部内部类(包含匿名内部类)。

    成员内部类

    定义格式:

    修饰符 class 类名称 {
        修饰符 class 类名称 {
            //...
        }
        //...
    }

    注意:

    内部类使用外部,可以随意访问,但是外部类使用内部类要借助内部类的对象。

    使用成员内部类

    两种方法:
    1. 间接方式:在外部类的方法中,使用内部类,然后main只调用外部类的方法。
    2. 直接方式:公式:
    一般类:类名称 对象名 = new 类名称();
    成员内部类:外部内名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();

    Body.java含有一个内部类Heart

    public class Body {
    
        private String name;
    
        //外部类方法
        public void methodBody() {
            System.out.println("外部类的方法");
            new Heart().beat();//在外部类方法中使用内部类。 
        }
    
    
        public  class Heart { //成员内部类
            //内部类方法
            public void  beat() {
                System.out.println("心脏跳动");
                System.out.println("我叫:"+name);
            }
        }
    }

    下面分别介绍两种方式访问内部类:

    间接方式访问内部类

    Demo01InnerClass.java

    public class Demo01InnerClass {
        public static void main(String[] args) {
            Body body = new Body();//外部类对象
    
            //通过外部类的对象,调用外部类的方法,里面间接使用内部类Heart
            body.methodBody();

    直接方式访问内部类

    public class Demo01InnerClass {
        public static void main(String[] args) {
            Body body = new Body();//外部类对对象
    
            //外部内名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
            Body.Heart heart = new Body().new Heart();
            heart.beat();
        }
    }

    外部类和内部类变量重名问题

    当外部类的变量和内部类变量重名时,在内部类方法中访问外部类变量的格式是:外部类.this.外部类成员变量名

    public class Outer {
        int number = 10;
    
        public class Inner {
            int number = 20;
    
            public  void methodInner() {
                int number =30;//内部类方法的局部变量
                System.out.println(number);//就近原则
                System.out.println(this.number);
                System.out.println(Outer.this.number);//外部类的成员变量
            }
        }
    }

    30
    20
    10


    局部内部类

    如果类是定义在一个方法内部的,那么这就是一个局部内部类。
    “局部”:只有当前所属的方法才能使用它,出了这个方法外面就不能用了。

    定义格式

    修饰符 class 外部类名称 {
        修饰符 返回值类型  外部类方法名称(参数列表) {
            class 局部内部类名称 {
                //...
            }
        }
    }

    Outer.java含有局部内部类

    public class Outer {
        public void methodOuter() {
    
            class Inner {
                int num = 10;
                public void methodInner() {
                    System.out.println(num);//10
                }
            }
            //这个内部列只有当前所属方法能够访问这个类,出了这个方法就不能用了
            Inner inner = new Inner();
            inner.methodInner();
        }
    }

    DemoMain.java

    public class DemoMain {
    
        public static void main(String[] args) {
            Outer outer = new Outer();
            outer.methodOuter();
        }
    }

    结果:
    10

    注意:

    局部内部类,如果希望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】
    备注:从java 8+开始,只要局部变量事实不变,那么final关键字可以省略。
    原因:
    1. new 出来的对象在堆内存当中。
    2. 局部变量是跟着方法走的,在栈内存当中。
    3. 方法运行结束后,立刻出栈,局部变量就会立刻消失。
    4. 但是new出来的对象在堆当中持续存在,直到垃圾回收消失。

    public class MyOuter {
        public void methodOuter() {
            final int num = 10;//所在方法的局部变量
    
            /*在栈中的局部变量可能随着方法结束出栈消失了,但是创建的内部类对象还存在。
            对象使用常量时能直接将常量copy进来,这时就要保证这个常量是不可更改的,也就是final。
            */
            //num = 20;
    
            class MyInner {
                public  void methodInner() {
                    System.out.println(num);
                }
            }
            Inner myinner = new MyInner();
            inner.methodInner();
        }
    }

    修饰内部类的权限

    public > protected > (default) > private
    定义一个类的时候,权限修饰符规则:

    1. 外部类:public / (default)
    2. 成员内部类:都可以写,public > protected > (default) > private
    3. 局部内部类:什么都不能写,但不是de

    匿名内部类

    如果接口的实现类(或者是父类的子类)只需要使用唯一的一次。
    那么这种情况下就可以省略调该类的定义,而改为使用【匿名内部类】。

    匿名内部类定义格式:

    接口名称 对象名 = new 类名或者接口名称() {
        //覆盖重写所有抽象方法
    };

    代表继承了或者实现了该接口的子类对象。

    ==接口MyInterface.java==

    public interface MyInterface {
        void method1();//抽象方法
        void method2();
    }

    ==接口实现类MyInterfaceImp.java==

    public class MyInterfaceImpl implements  MyInterface {
    
    
        @Override
        public void method1() {
            System.out.println("实现类覆盖重写了方法1");
        }
    
        @Override
        public void method2() {
            System.out.println("实现了覆盖重写方法2");
        }
    }

    测试类

    一、一般接口实现方法

    DemoMain.java

    public class DemoMain {
        public static void main(String[] args) {
    //        MyInterface impl = new MyInterfaceImpl();
    //        impl.method();
            }
    }

    匿名内部类实现接口

    DemoMain.java

    public class DemoMain {
        public static void main(String[] args) {
    
            //使用匿名内部类,但不匿名对象,对象名称就叫obj
            MyInterface objA = new MyInterface() {
                @Override
                public void method1() {
                    System.out.println("匿名内部类实现了方法1-A");
                }
                @Override
                public void method2() {
                    System.out.println("匿名内部类实现了方法2-A");
                }
            };
            objA.method1();
            objA.method2();
    
            System.out.println("----------我是分割线----------");
    
            //使用匿名内部类,而且省略了对象名称,也是匿名对象
            new MyInterface() {
                @Override
                public void method1() {
                    System.out.println("匿名内部类实现了方法1-B");
                }
                @Override
                public void method2() {
                    System.out.println("匿名内部类实现了方法2-B");
                }
            }.method1();
        }
    }

    结果:
    匿名内部类实现了方法1-A
    匿名内部类实现了方法2-A
    ----------我是分割线----------
    匿名内部类实现了方法1-B

    匿名内部内应用

    • 实现倒计时5秒。
    public class Demo02_Time {
        public static void main(String[] args) {
            Timer timer = new Timer();
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("倒计时5秒");
                }
            },5000);//倒计时5秒
        }
    }

    注意事项:

    对格式进行解析:"new 接口名称 {...};"进行解析

    1. new代表创建对象的动作
    2. 接口名称就是匿名内部类需要实现那个接口
    3. {…}这才是匿名内部类的内容

    注意:

    1. 这个类只需要使用一次。匿名内部类在创建对象时,只能使用唯一一次。
      如果希望多次希望多次创建对象,而且内容一样的话,那么就必须使用单独定义的实现类。

    2. 匿名对象,在调用的时候,只能调用唯一一次。
      如果希望同一个对象,调用多次方法,那么必须给对象取一个名字。

    3. 匿名内部类是省略了【实现类/子类】,但是匿名对象是省略了【对象命名】。

    强调:匿名和匿名对象不是一回事。

    展开全文
  • 成员内部类 局部内部类(包含匿名内部类) 成员内部类 定义格式: 修饰符 class 外部类名称 { 修饰符 class 内部类名称 { // .... } // .... } 内部类的class文件命名为:外部类$内部类.class 使用成员内部类 ...

    如果一个事物的内部包含另一个事物,那么这就是一个类内部包含另一个类。

    分类:

    1. 成员内部类
    2. 局部内部类(包含匿名内部类)

    成员内部类

    定义格式:

    修饰符 class 外部类名称 {
        修饰符 class 内部类名称 {
            // ....
        }
        // ....
    }
    

    内部类的class文件命名为:外部类$内部类.class

    使用成员内部类

    1. 间接方式: 在外部类的方法当中,使用内部类;然后main方法调用外部类的方法。
    2. 直接方式:
      格式:
    外部类名称 内部类名称 对象名 = new 外部类名称().new 内部类名称()
    

    内部类的同名变量访问

    如果内部类和外部类出现了重名现象,那么访问格式为:

    // 类名称.this.类成员变量名;
    public class Outer {
        private int num = 10;
        
        public class Inner {
            
            int num = 20;
            
            public void method {
                
                int num = 30;
                System.out.println(num); // 30
                System.out.println(this.num); // 20
                System.out.println(Outer.this.num); // 10
            }
    
    }
    

    局部内部类定义

    如果一个类的成员方法里面定义了一个类,那么里面的类就是局部内部类。

    定义格式:

    修饰符 class 外部类名称 {
        修饰符 返回值类型 外部类方法名称(参数列表) {
            class 局部内部类名称 {
                // ...
            }
        }
    }
    

    注意: 定义一个类的时候,权限修饰符规则:

    • 外部类:public/ (default)
    • 成员内部类:public/ protected/ (default)/ private
    • 局部内部类:什么都不能写

    局部内部类的final问题

    局部内部类,如望访问所在方法的局部变量,那么这个局部变量必须是【有效final的】。

    备注: 从Java8+开始,只要局部变量事实不变,那么 final关键字可以省略。

    原因:

    1. new出来的对象在堆内存当中。
    2. 局部变量是跟着方法走的,在栈内存当中
    3. 方法运行结束之后,立刻出栈,局部变量就会立刻消失。
    4. 但是new出来的对象会在堆当中持续存在,直到垃圾回收消失。
    5. 因此如果对象想调用已经消失的局部变量就必须将值复制到方法的变量中,不可更改。

    * 匿名内部类

    如果接口的实现类(或者是父类的子类)只需要使用唯一的一次,那么这种情况下就可以省略掉该类的定义,而改为使用【匿名内部类】。

    匿名内部类的定义格式:

    接口名称 对象名 = new 接口名称() {
        // 覆盖重写所有抽象方法
    }; // 注意末尾的分号不能省略
    

    好处:不必再为了实现一个接口而单独定义一个类。

    匿名内部类的注意事项

    对格式new 接口名称(){...}进行解析:

    1. new代表创建对象的动作
    2. 接口名称就是匿名内部类需要实现哪个接口
    3. {...}这才是匿名内部类的内容

    另外还要注意几点问题:

    1. 匿名内部类,在【创建对象】的时候,只能使用唯一一次。
      如果希望多次创建对象,而且类的内容一样的话,那么就必须使用单独定义的实现类。
    2. 匿名对象,在【调用方法】的时候,只能调用唯一一次
      如果希望同一个对象,调用多次方法,那么必须给对象起个名字。
    3. 匿名内部类是省略了【实现类/子类名称】,匿名对家是省略了【对象名称】
    // 定义一个匿名内部类+匿名对象
    new InterfaceImpl {
        @Override
        public void method {
            System.out.println("定义了一个匿名内部类+匿名对象")
        }
    }.method;
    
    // 输出为:定义了一个匿名内部类+匿名对象
    
    展开全文
  • 成员内部类、成员静态内部类
  • 成员内部类 静态内部类 局部内部类 匿名内部类
  • 内部类分为三种:成员内部类,静态内部类,方法内部类,匿名内部类。成员内部类成员内部类在类中相当于类的成员。(就相当于类内部的一个成员) 特点:成员内部类可以访问外部类的所有成员,并且内部类可以在外部类...
  • Java基础笔记 – 内部类 静态内部类 成员内部类 局部内部类 匿名内部类 本文由包小卷发表于2年前 | Java基础 | 评论关闭 | 被围观 2,995 views+ 内部类: 使用内部类减少了命名冲突。 一个内部类可以定义在一个类...
  • 根据内部类的位置、修饰符和定义的方式可分为成员内部类、静态内部类、方法内部类。 成员内部类: 在一个类中除了可以定义成员变量、成员方法,还可以定义类,这样的类被称为成员内部类。 class Inside { // ...
  • Demo01: ... /*内部类:一个事物的... 分类:成员内部类 局部内部类(包含匿名内部类) 成员内部类的使用: 1.间接调用:通过创建外部类对象,调用外部类方法使用内部类 2.直接调用,直接创建一个内部类对象 ...
  • Java 内部类 分四种:成员内部类、局部内部类、静态内部类和匿名内部类。 1、成员内部类:即作为外部类的一个成员存在,与外部类的属性、方法并列。 注意:成员内部类中不能定义静态变量,但可以访问外部类的所有成员...
  • Java 内部类整理(静态内部类、成员内部类、局部内部类、匿名内部类) 一、内部类: 在Java中,将一个类的定义放在另一个类的定义内部,这就是内部类。内部类本身就是一个类的属性。 举个栗子: public class Outer { ...
  • 一、内部类 1、定义:一个类定义在...1)成员内部类: a)成员内部类的访问方式: 方式一:在外部类提供一个方法创建内部类的对象进行访问。 方式2二:在其他类直接创建内部类的对象。 格式:外部类.内部类 变量
  • 目录成员内部类静态内部类方法内部类完整程序 成员内部类 成员内部类创建对象必须使用外部类对象来创建内部类对象,而不能直接new内部类构造方法的方式创建; //普通成员内部类创建对象,需通过外部类对象进行...
  • 成员内部类 1.内部类可以直接存取所在类的私有成员变量,内部类的实例一定要绑定在外部类的实例上 2.子类中使用外部类.this可以调用外部类成员变量 使用内部类.this可以调用内部类成员变量 3.内部类向上转型为接口...
  • 分为两种: 一个是 成员内部类 ,一个是 局部内部类(包含匿名内部类) 2、成员内部类的定义及使用 定义: 修饰符 class 外部类名称 { ... 修饰符 class 成员内部类名称 { ... } } 使用方法:   简接调...
  • 内部类(Inner Class)就是定义在另外一个类里面的类。内部类有以下分类:成员内部类、静态内部类、方法内部类、匿名内部类
  • * 标题:Java内部类[成员内部类、局部内部类、匿名内部类和静态内部类] * * 作者:Nstar * * 时间:2020年3月13日 * * 内容: * * 问:什么是内部类? * 答:在 Java 中,可以将一个类定义在另一个类里面或者一...
  • inner classes)1.1、相关使用例子:2、成员内部类(member inner classes):2.1、相关使用例子:3、局部内部类(local inner classes):3.1、相关使用例子:4、匿名内部类(anonymous inner classes):4.1、相关...
  • 成员内部类也叫普通内部类、常规内部类。它有如下特点:成员内部类定义在另一个类中,但是定义时不用static修饰。 它可以访问它的外部类的所有成员变量和方法,不管是静态的还是非静态的。 在外部类里面创建成员内部...
  • 一:成员内部类:最常见的内部类就是成员内部类,也称作普通内部类;1、Inner类定义在Outer类的内部,相当于Outer类的成员变量的位置,Inner类可以使用任意访问修饰符,如:public、private、protected等。2、Inner...
  • 对于成员内部类的使用场景最大的优点:内部类可以独立的继承一个接口的实现,所以 无论外部类是否已经继承一个接口的实现,对内部类偶读没有影响,内部类使得类的 多继承的解决方案变得完整, 当外部类和内部类有...
  • Java 内部类分四种:成员内部类、局部内部类、静态内部类和匿名内部类。
  • 成员内部类class Demo1_InnerClass { public static void main(String[] args) { //Inner i = new Inner(); //i.method(); //外部类名.内部类名 = 外部类对象.内部类对象 Outer.Inner oi = new Outer().new...
  • (一)成员内部类 1.
  • 成员内部类 /** * @author Ziph * @date 2020年2月28日 * @Email mylifes1110@163.com * * 打印结果: * This is OuterClassMethod * 111 * 222 * This is InnerClassMethod * 222 */ //成员内部类 public class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,648
精华内容 11,059
关键字:

成员内部类