java内部类

本文主要是介绍java内部类，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

内部类

首先讲一下类的五大成员：属性，方法，构造器，代码块，内部类。

内部类就是类中嵌套另外的类，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类中间的包含关系。

局部内部类

局部内部类定义在外部类的方法或者代码块中。
可以直接访问外部类的所有成员包括私有成员。
不能添加访问修饰符，但是可以使用final。
作用域：仅仅在定义它的方法或者代码块中。
外部类访问内部类需要在作用于内创建对象。

public class LocalInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.m1();

    }
}

class Outer {
    private int n = 1;

    public void m3() {
        System.out.println("这是m3()方法。");
    }

    //在方法中或者代码块中写内部类。
    public void m1() {
        final class Inner {//不能添加访问修饰符，可以使用final修饰。

            public void m2() {
                System.out.println(n);
                m3();
            }

        } 
        //外部类在方法中，可以创建内部类对象，然后访问内部类的方法。
        Inner inner = new Inner();
        inner.m2();

    }
}

如果外部类和局部类有重名成员时，默认就近原则，如果想访问外部类的成员，则可以使用（外部类.this.成员）

public class LocalInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.m1();

    }
}

class Outer {
    private int n = 1;//外部类的n。

    public void m3() {
        System.out.println("这是m3()方法。");
    }

    //在方法中或者代码块中写内部类。
    public void m1() {
        final class Inner {//不能添加访问修饰符，可以使用final修饰。
              private int n=3;//内部类的n;
            public void m2() {
                System.out.println(n);
                System.out.println("外部类的n值是:"+Outer.this.n);//访问外部属性n。
                m3();
            }

        }
        //外部类在方法中可以创建内部类对象，然后访问内部类的方法。
        Inner inner = new Inner();
        inner.m2();

    }
}

匿名内部类

定义:本质是类，定义在外部类的局部位置（方法或者代码块中。）

为什么要使用匿名内部类？

因为有些类只是用一次，后面不再使用，所以用匿名内部类简化开发。

基本语法：new 类或者接口{

类体

};

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

class Outer {
    public void method() {
        //IB是编译类型，真正的的运行类型是匿名内部类Outer$1。
        IB tiger = new IB() {

            @Override
            public void cry() {
                System.out.println("Tiger叫唤。");
            }
        };
        tiger.cry();
        System.out.println(tiger.getClass());//class com.zj.AnonymousInnerClass.Outer$1,实际的匿名内部类类名，它是底层分配的，不显示。
    }
}
interface IB{
    void cry();

public class Anonymous02 {
    public static void main(String[] args) {
        Outer02 outer = new Outer02();
        outer.method();
    }
}
class Outer02{
    public void method(){
        Father father=new Father("张三"){

        };     
        Mother mother=new Mother() {
            @Override
            public void hello() {
                System.out.println("我是Hello.");
            }
        };
        mother.hello();
         System.out.println(father.getClass());
    }


}
class Father{
String name;
    public Father(String name){
        this.name=name;
        System.out.println("名字是："+this.name);
    }
    public void hi(){

    }
}
abstract class Mother{
    abstract public void hello();
}
//名字是：张三
//class com.zj.AnonymousInnerClass.Outer02$1
//我是Hello.

注意细节

可以直接访问外部类的所有成员，包括私有的。
不能添加访问修饰符，因为它就是一个局部变量。
作用域仅仅在方法或者代码块中。
匿名内部类直接访问外部类成员。
外部其他类不能访问匿名内部类。
（类似于局部内部类）如果外部类和内部类重名时，内部类访问的话默认就近原则，如果想访问外部类的成员，则可以使用(外部类.this.成员)

匿名内部类使用的实践：

public class AnonymousExercise02 {
    public static void main(String[] args) {
        CellPhone cellPhone = new CellPhone();
        CellPhone cellPhone1 = new CellPhone();
        cellPhone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小猪起床了。");
            }
        });
        cellPhone1.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小可爱起床了。");
            }
        });
    }

}
interface Bell{
    void ring();
}
class CellPhone{
    public void alarmClock(Bell bell){
        System.out.println(bell.getClass());
        bell.ring();
    }
}
//class com.zj.AnonymousInnerClass.AnonymousExercise02$1
//小猪起床了。
//class com.zj.AnonymousInnerClass.AnonymousExercise02$2
//小可爱起床了。

成员内部类：

定义在外部类的成员位置上。
可以直接访问外部类的所有信息。
可以添加任何访问修饰符，因为它本身就是一个成员。

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

}
class Outer{
    private int n=10;
    public String name="张三";
    //成员内部类。
    class Inner{
        public void say(){
            System.out.println("n="+n+",name="+name);
        }
    }
    public void t1(){
        Inner inner = new Inner();
        inner.say();
    }
}

外部其他类使用成员内部类的三种方式。

1.外部类的对象.new 内部类（语法记住就行。）

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.t1();
        //外部其他类访问成员内部类。
        Outer.Inner inner = outer.new Inner();
        inner.say();

    }

}
class Outer{
    private int n=10;
    public String name="张三";
    class Inner{
        public void say(){
            System.out.println("n="+n+",name="+name);
        }
    }
    public void t1(){
        Inner inner = new Inner();
        inner.say();
    }
}

2.写一个方法返回一个实例。

public class MemberInnerClass {
    public static void main(String[] args) {
        
        Outer.Inner instance = outer.getInstance();
        instance.say();

    }

}
class Outer{
    private int n=10;
    public String name="张三";
    class Inner{
        public void say(){
            System.out.println("n="+n+",name="+name);
        }
    }
    public Inner getInstance(){
        return new Inner();
    }
   
}

静态成员类

使用static修饰。
可以直接访问所有静态成员，但是不能访问非静态成员。
可以添加任何访问修饰符。因为它的地位相当于一个成员。
外部类访问内部类的方式。直接创建一个方法然后new对象再调用静态内部类的方法。

外部类和内部类成员重名时,默认就近原则。如果想访问外部类的成员用外部类.成员。

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

}
class Outer{
    private int n=11;
    private static String name="张三";
    static class  Inner{
        public void say(){
            System.out.println("name= "+name);
        }

    }
    public void hi(){
        Inner inner = new Inner();
        inner.say();
    }
}

外部其他类调用静态内部类的方式。

new 外部类.内部类（）

public class StaticInnerClass01 {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
        inner.say();
      
    }

}
class Outer{
    private int n=11;
    private static String name="张三";
    static class  Inner{
        public void say(){
            System.out.println("name= "+name);
        }

    }
   
}

写一个方法返回实例。

public class StaticInnerClass01 {
    public static void main(String[] args) {
        //外部类调用
        Outer outer = new Outer();
        Outer.Inner instance = outer.getInstance();
        instance.say();

    }

}
class Outer{
    private int n=11;
    private static String name="张三";
    static class  Inner{
        public void say(){
            System.out.println("name= "+name);
        }

    }
    //定义一个实例方法。
    public Inner getInstance(){
        return new Inner();
    }
}

这篇关于java内部类的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

java内部类

内部类

局部内部类

匿名内部类

注意细节

匿名内部类使用的实践：

成员内部类：

外部其他类使用成员内部类的三种方式。

静态成员类

外部其他类调用静态内部类的方式。

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯