Java面向对象-内部类、枚举

闲不住的码
245 阅读4分钟

Java面向对象-内部类、枚举

内部类

什么是内部类

是类中的五大成分之一（成员变量、方法、构造器、内部类、代码块〉，如果一个类定义在另一个类的内部，这个类就是内部类。

场景: 当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。

public class Car{
    //内部类
    public class Engine{}
}

成员内部类

就是类中的一个普通成员，类似前面我们学过的普通的成员变量、成员方法。

public class outer {
    //成员内部类：
    private String name="大三";
​
    public class inner{
        //成员变量
        private String name="小三";
        public void test(){
            //也有成员方法
            System.out.println(name); //小三
            System.out.println(outer.this.name); //大三
        }
    }

注意:JDK16之前，成员内部类中不能定义静态成员，JDK 16开始也可以定义静态成员了

创建对象的格式:

//外部类名.内部类名对象名= new外部类( ... ).new 内部类(...);
Outer.Inner in=new Outer().new Inner();

成员内部类中访问其他成员的特点:

  1. 和前面学过的实例方法一样，成员内部类的实例方法中，同样可以直接访问外部类的实例成员、静态成员。
  2. 可以在成员内部类的实例方法中，拿到当前外部类对象，格式是:外部类名.this
public class outer {
    //成员内部类：
    private String name="大三";
    public class inner;
        public void test(){
            //访问外部类的对象
            System.out.println(outer.this.name); //大三
        }
    }
}

静态内部类

有static修饰的内部类，属于外部类自己持有。

public class Outer{
    //静态内部类
    public static class Inner{}
}

创建对象的格式:

//外部类名.内部类名对象名=new外部类.内部类(.….);
Outer.lnner in = new Outer.Inner();

静态内部类中访问外部类成员的特点:

可以直接访问外部类的静态成员，不可以直接访问外部类的实例成员。

局部内部类

局部内部类是定义在在方法中、代码块中、构造器等执行体中。

public class Test1 {
    public static void main(String[] args) {
​
    }
    public static void go(){
       class A{
        //局部内部类
       }
       abstract class B{
​
       }
    }
}

一般用的很少，了解一下就可以了

匿名内部类

就是一种特殊的局部内部类;所谓匿名:指的是程序员不需要为这个类声明名字。

public abstract class Animal {
    public abstract void cry();
}

public class Test1 {
    public static void main(String[] args) {
​
    Animal a=new Animal() {  //这里就是一个匿名内部类，我们并不知道这个子类的具体名称
        @Override
        public void cry() {   //实现父类的方法
            System.out.println("我会唱歌");
        }
    };
    }
}

特点:匿名内部类本质就是一个子类，并会立即创建出一个子类对象。

作用:用于更方便的创建一个子类对象。

匿名内部类常见的应用场景

在开发中使用最多的就是匿名内部类，常见的应用场景

  1. 在GUI编程中给按钮绑定单击事件监听器

    btn.addActionListener(new ActionListener(){
    @Override
    public void actionPerformed(ActionEvent e){
        
    }
});

  2. 通常作为一个参数传输给方法

枚举

枚举是一种特殊类。

枚举类的格式:

//修饰符 enum 枚举类名{
   //名称1、名称2、......
     //  其他成员......
//}
public enum Ademo {  //枚举类
    X ,Y,Z  ; //枚举类的第一行只能写一写名称，常量
    private String name;
    public static int age;
}

注意:

枚举类中的第一行，只能写一些合法的标识符(名称) ，多个名称用逗号隔开。这些名称，本质是常量，每个常量都会记住枚举类的一个对象。

获取枚举：

public class demo1 {
    public static void main(String[] args) {
        Ademo a=Ademo.X;
//        Ademo b=new Ademo();   枚举类不可以创建对象，
        Ademo[] ab=Ademo.values(); //获取所有的对象
        System.out.println(a.name());
        System.out.println(ab); //数组需要遍历才可以获取到所有的值
    }
}

枚举的特点：

  1. 枚举类的第一行只能罗列一些名称，这些名称都是常量，并且每个常量记住的都是枚举类的一个对象。
  2. 枚举类的构造器都是私有的(写不写都只能是私有的)，因此，枚举类对外不能创建对象。
  3. 枚举都是最终类，不可以被继承。
  4. 枚举类中，从第二行开始，可以定义类的其他各种成员。
  5. 编译器为枚举类新增了几个方法，并且枚举类都是继承: java.lang.Enum类的，从enum类也会继承到一些方法。

抽象枚举

public enum AA {
    X(){
        @Override
        public void go() {
            System.out.println("快跑");  //常量必须实现抽象方法
        }
    },Y {
        @Override
        public void go() {
​
        }
    };
​
    public abstract void go();  //抽象方法
}

public class text1 {
    public static void main(String[] args) {
     AA as=AA.X;
        System.out.println(as);  //X
        as.go();  //快跑
    }
​
}

枚举的常见应用场景

  1. 用来表示一组信息，然后作为参数进行传输。
  2. 选择定义一个一个的常量来表示一组信息，并作为参数传输，参数值不受约束。
  3. 选择定义枚举表示一组信息，并作为参数传输，代码可读性好，参数值得到了约束，对使用者更友好，建议使用!
avatar
文章
阅读
粉丝