Java学习13

news2024/11/15 19:24:42

一.内部类:

1.概念：

2.内部类的分类：

（1）定义在外部类的局部位置上（通常在方法体中）：

1. 局部内部类（有类名）

2.匿名内部类（无类名-重点！！！）

3.匿名内部类的细节：

（2）定义在外部类的成员位置：

3.成员内部类（不用static修饰）

4.静态内部类（使用static修饰）

二.枚举：

1.定义：

2.自定义枚举：

3.使用关键字enum来实现枚举：

4.enum关键字实现枚举的注意事项：

5.enum方法介绍：

三.注解：

（1）注解细节：

（2）元注解：

1.Retention:

2.Target:

3.Document:

4.Inherited:

一.内部类:

1.概念：

一个类的内部又完整的嵌套另一个类，被嵌套的类称为内部类，嵌套其他类的类称为外部类，类的五大成员包括属性、方法、构造器、代码块、内部类。内部类的最大特点就是可以直接访问私有熟悉，并且可以体现类与类之间的包含关系。

2.内部类的分类：

（1）定义在外部类的局部位置上（通常在方法体中）：

1. 局部内部类（有类名）

可以直接访问外部类的所有成员，包括私有的，作用域位于定义它的方法或代码块中。
不能添加访问修饰符，因为它是局部变量，局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量可以使用final修饰。
局部内部类可以直接访问外部类的成员，外部其他类不能访问局部内部类。
如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员则可以使用【外部类名.this.成员】去访问。

class Outer{
   private int n1 = 100;
   private void m2(){
      System.out.println("Outer m2()");
   }
   public void m1(){
      final class Inner {
          private int n1 = 200;
          public void f1(){
             System.out.println("Inner"+n1);//就近原则输出200
             System.out.println("Outer"+Outer.this.n1);//输出100
             m2();
          }
      }
   }
}

2.匿名内部类（无类名-重点！！！）

本质：匿名内部类是无名字的内部类，同时是一个对象。
基本语法：new 类或接口（参数列表）{类体}；

3.匿名内部类的细节：

可以访问外部类的所有成员，包括私有的
不能添加访问修饰符，因为它是一个局部变量。
作用域：仅仅在定义它的方法或代码块中
如果外部类和匿名内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员则可以使用【外部类名.this.成员】去访问。

class Outer04{
    private int n1 =10;
    public void method() {
        //tiger的编译类型是接口IA，运行类型是匿名内部类。
        //匿名内部类使用一次就不能再使用
        // class Outer04$1 implements IA{
        //public void cry() {
        //System.out.println("老虎叫");
        //}
        //}
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎叫");
            }
        };
        tiger.cry();
        Father father = new Father("jack");//father1编译类型Father,运行类型Father
        Father father1 = new Father("jack"){//创建匿名内部类,father1编译类型Father,运行类型Outer04$2
            //参数Jack会传递给构造器
            @Override
            public void test() {
                System.out.println("匿名内部类重写test()方法");
            }
        };
        System.out.println("father对象的运行类型"+father1.getClass());//Outer04$2
        father1.test();
        new Father("tom"){//匿名内部类返回对象，可直接调用方法
            @Override
            public void test() {
                super.test();//Father类中的test方法
                System.out.println("重写匿名内部类2");
            }
        }.test();//匿名内部类返回对象，可直接调用方法
}
}
interface IA {
    public void cry();}
class Father {
    public Father(String name){ }
    public void test(){
    System.out.println("Father类中的test方法");}
}

（2）定义在外部类的成员位置：

3.成员内部类（不用static修饰）

（1）概念：定义在外部类的成员位置，并且没有static修饰。

（2）细节：

可以直接访问外部类的所有成员，包含私有的，可以添加任意访问修饰符。外部类也可以直接访问内部类中的成员。
作用域：和外部类的其他成员一样，为外部类的整体。
如果外部类和成员内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员则可以使用【外部类名.this.成员】去访问。
外部类访问内部类的三种方法：

public class InnerClassExercise01 {
    public static void main(String[] args) { 
       Outer08 outer08 = new Outer08;
       outer08.t1();
       //相当于把new Inner08()当做outer08成员(第一种方法得到Inner08的对象实例)
       Outer08.Inner08 inner08 = outer08.new Inner08();（第二种方法）
       Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
       Outer08.m1();
       Outer08.Inner10 inner100 = new Outer.Inner10();//静态内部类可以通过类名直接访问(方法一)
       Outer08.Inner10 inner101 = outer08.getInner10();
       Outer08.Inner10 inner102 = Outer08.getInner10();
       inner10.say();
       
    } 
}
class Outer08{
      private int n1=10;
      class inner08{//成员内部类
      public double sal =99.8;
      public void say(){
             System.out.println("n1="+n1); 
      }
      }
     //第二种方法得到Inner08的实例
      public Inner08 getInner08Instance(){
             return new Inner08();
      }     
      public void t1(){
             Inner08 inner = new Inner08();
             Inner08.say();
      }
       static class Inner10{//静态内部类
              public void say(){
              System.put.println(name);
              say();
              }
       }
       public void m1(){
             Inner08 inner10 = new Inner10();
             Inner10.say();
      }
       public Inner10   getInner10(){
              return new Inner10();  
}

4.静态内部类（使用static修饰）

（1）概念：定义在外部类的成员位置，并且有static修饰。

（2）细节：

可以访问外部类的所有静态成员，包含私有的，但是不能直接访问非静态成员。
可以添加任意修饰符，作用域为整个整体。
如果外部类和静态内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员则可以使用【外部类名.成员】去访问。

二.枚举：

1.定义：

枚举是一组常亮的集合，属于一种特殊的类，里面只包含一组有限的特定的对象。

2.自定义枚举：

将构造器私有化
删除set相关方法，防止属性被修改
在season内部，直接创建固定的对象

3.使用关键字enum来实现枚举：

使用关键字enum来替代class
常量名（实参列表）
如果有多个常量对象，使用，间隔即可
如果使用enum来实现枚举要求将定义的常量对象写在前面。

4.enum关键字实现枚举的注意事项：

当使用enum关键字开发一个枚举类时，默认会继承Enum类，而且是一个final类。
如果使用无参构造器创建枚举对象时，则无参构造器可以省略括号--（）。
当有多个枚举对象时，使用，间隔，最后用一个分号结尾。
枚举对象必须放在枚举类的行首。
使用enum关键字后，就不能再继承其他类了，enum会隐式继承Enum。
枚举类和普通类一样可以实现接口。

5.enum方法介绍：

（1）values :返回当前枚举类中所有的常量

Season[] values = Season.values();
for(Season season:values){//增强for循环
   System.out.println(season);
}

（2）valuesof：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则异常

根据你输入的"AUTUMN"到Season的枚举对象去查找，找到了就返回，没找到就报错。

Season autumn1 = Season.valuesof("AUTUMN");
System.out.println("autumn1="+autumn1);//autumn1=Season{name='秋天',desc='温暖'}
System.out.println(autumn == autumn1);//true

（3）compareTo:比较两个枚举变量的编号（Season.AUTUMN--枚举对象）