JavaSE学习小结-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_45710407/article/details/122778704

本文详细总结了Java SE中的关键概念，包括封装、构造块与静态代码块、单例设计模式（饿汉式与懒汉式）、final关键字、多态性（概念、特点、类型转换）、抽象方法与抽象类、接口、内部类（普通、静态、局部、匿名）以及枚举类型。通过实例解析了各种特性的应用场景和实现方式，深入理解Java面向对象编程的核心知识。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

JavaSE学习小结

记录学习----------JavaSE模块二

一、封装的概念与示例

通常情况下可以在测试类给成员变量赋值一些合法但不合理的数值，无
论是编译阶段还是运行阶段都不会报错或者给出提示，此时与现实生活
不符。
为了避免上述错误的发生，就需要对成员变量进行密封包装处理，来隐
藏成员变量的细节以及保证成员变量数值的合理性，该机制就叫做封装

代码如下（示例）：

/**
 - 封装：
 -  私有化成员变量，使用private关键字修饰。
 -  提供公有的get和set方法，并在方法体中进行合理值的判断。
 -  在构造方法中调用set方法进行合理值的判断
 */
public class People {
    private String name;
    private int age;
    private boolean gender; // true 等价于 men， false 等价于 women

    public People() {}

    public People(String name, int age, boolean gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 0 && age < 150)
            this.age = age;
        else
            System.out.println("error!");
    }
    
    //这个是boolean类型的getter
    public boolean isGender() { 
        return gender;
    }

    public void setGender(boolean gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        String gd = "wemon";
        if(isGender())
            gd = "men";
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gd +
                '}';
    }
}

二、构造快与静态代码块

1.构造块：在类体中直接使用{}括起来的代码块。

每创建一个对象都会执行一次构造块

2.静态代码块：使用static关键字修饰的构造块。

静态代码块随着类加载时执行一次

代码如下（示例）：

public class BlockTest {
    {
        System.out.println("构造块");
    }

    static {
        System.out.println("******静态代码块******");
    }

    BlockTest() {
        System.out.println("构造方法体");
    }

    public static void main(String[] args) {
        BlockTest t1 = new BlockTest();

        BlockTest t2 = new BlockTest();
    }
}

运行结果如下（示例）：
在这里插入图片描述

3.构造块与静态代码块的笔试考点

public class SuperTest {

    {
        System.out.println("SuperTest类中的构造块！"); // a
    }

    static {
        System.out.println("SuperTest类中的静态代码块！"); // b
    }

    public SuperTest() {
        System.out.println("SuperTest类中的构造方法体！"); // c
    }

    public static void main(String[] args) {

        // 使用无参方式构造对象
        SuperTest st = new SuperTest();
    }
}


public class SubSuperTest extends SuperTest {

    {
        System.out.println("==========SubSuperTest类中的构造块！"); //d
    }

    static {
        System.out.println("==========SubSuperTest类中的静态代码块！"); //e
    }

    public SubSuperTest() {
        //System.out.println("==========SubSuperTest类中的构造方法体！"); // f
        out.println("==========SubSuperTest类中的构造方法体！");
    }

    public static void main(String[] args) {

        // 使用无参方式构造子类的对象
        SubSuperTest sst = new SubSuperTest();
    }
}

运行结果为： b e a c d f
这是因为子类要先创建父类，并且静态代码块是随着类的加载而运行的，因此两个静态代码块会先输出内容，之后才是父类的构造快、父类的构造方法、子类的构造块、子类的构造方法。

三、单例设计模式

单例设计模式的概念：在某些特殊场合中，一个类对外提供且只提供一个对象时，这样的类叫
做单例类，而设计单例的流程和思想叫做单例设计模式。
单例设计模式的实现流程：
1. 私有化构造方法，使用private关键字修饰。
2. 声明本类类型的引用指向本类类型的对象，并使用private static关键字共
  同修饰。
3. 提供公有的get方法负责将对象返回出去，并使用public static关键字共同
  修饰。

饿汉式创建单例对象

饿汉式在类加载时已经创建好该对象，在程序调用时直接返回该单例对象即可，即我们在编码时就已经指明了要马上创建这个对象，不需要等到被调用时再去创建。

代码示例：

/**
 * 单例设计模式 --- 饿汉式，即声明对象时直接new
 */
public class Singleton {
    // 2. 声明本类类型的引用指向本类类型的对象，并使用private static关键字共同修饰
    private static Singleton ob1 = new Singleton();

    // 1.私有化构造方法
    private Singleton() {}

    // 3.提供公有的get方法负责将对象返回出去，并使用public static关键字共同修饰
    public static Singleton getOb1() {
        return ob1;
    }
}

懒汉式创建单例对象

懒汉式创建对象的方法是在程序使用对象前，先判断该对象是否已经实例化（判空），若已实例化直接返回该类对象。，否则则先执行实例化操作。

代码示例：

/**
 * 单例设计模式 --- 懒汉式
 */
public class Singleton {
    // 2. 声明本类类型的引用指向本类类型的对象，并使用private static关键字共同修饰
    private static Singleton ob1 = null;

    // 1.私有化构造方法
    private Singleton() {}

    // 3.提供公有的get方法负责将对象返回出去，并使用public static关键字共同修饰
    public static Singleton getOb1() {
        if(ob1 == null)
            ob1 = new Singleton();
        return ob1;
    }
}

目前上面这段代码已经实现了一个懒汉式的单例模式，虽然不完美但是不影响我们使用它。

进一步优化：针对线程安全的优化（目前自身能力只能考虑到这里了）

我们先看一下懒汉式单例模式的核心方法：

public static Singleton getOb1() {
        if(ob1 == null)
            ob1 = new Singleton();
        return ob1;
    }

这个方法之所以存在线程安全的问题是因为，如果存在两个线程 A 和 B，同时在判断得到 Singleton 对象 ob1 为 null ,就会调用构造方法，对 ob1 进行实例化，这样的话我们得到的就不是单例而是 “ 双 ” 例了。所以我们要做的就是解决线程安全问题。

其中最简单的解决方法就是：加锁，那么就可以得到一下代码：

public static synchronized Singleton getOb1() {
    if (ob1 == null) {
        ob1 = new Singleton();
    }
    return ob1;
}
// 或者
public static Singleton getOb1() {
    synchronized(Singleton.class) {   
        if (ob1 == null) {
            ob1 = new Singleton();
        }
    }
    return singleton;
}

接下来我们要做的就是优化性能，这是因为每次去获取对象都需要先获取锁，并发性能非常地差。因此我们的目标就是：如果没有实例化对象则加锁创建，如果已经实例化了，则不需要加锁，直接获取实例

public static Singleton getOb1() {
    if (ob1 == null) {  // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
        synchronized(Singleton.class) { // 线程A或线程B获得该锁进行初始化
            if (ob1 == null) { // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                ob1 = new Singleton();
            }
        }
    }
    return ob1;
}

第2行代码，如果singleton不为空，则直接返回对象，不需要获取锁；而如果多个线程发现singleton为空，则进入分支；
第3行代码，多个线程尝试争抢同一个锁，只有一个线程争抢成功，第一个获取到锁的线程会再次判断singleton是否为空，因为singleton有可能已经被之前的线程实例化
其它之后获取到锁的线程在执行到第4行校验代码，发现singleton已经不为空了，则不会再new一个对象，直接返回对象即可
之后所有进入该方法的线程都不会去获取锁，在第一次判断singleton对象时已经不为空了

四、final关键字

final关键字修饰类体现在该类不能被继承。
主要用于防止滥用继承，如：java.lang.String类等，示例如下：

其中我们可以看到IDEA给我们的报错很明确：Cannot inherit from final 即不能继承被final关键字修饰的类
final关键字修饰成员方法体现在该方法不能被重写但可以被继承。
主要用于防止不经意间造成重写，如：java.text.Dateformat类中format方法等。示例如下：

/*
* 这个方法是不能被重写
*/
public final void printMas() {
	System.out.println("This is a method modified by final.");
}

/*
* 而这个方法是可以的
*/
public void printMas() {
	System.out.println("You can override it.");
}

final关键字修饰成员变量体现在该变量必须初始化且不能改变。
主要用于防止不经意间造成改变，如：java.lang.Thread类中MAX_PRIORITY等。
其实用final关键字修饰变量不太常用，我们更多的是用public static final进行修饰表示一个常量，比如：自然对数的底e≈ 2.71828

public static final double E =  2.71828;

五、多态

1. 多态的概念

Java的三大特性分别是：封装、继承和多态
同一事务表现出的多种形态，语法格式：父类类型引用变量名 = new 子类类型()；
示例如下：

public class Shape {
    private int x;
    private int y;

    public Shape() {
    }

    public Shape(int x, int y) {
        setX(x);
        setY(y);
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public void printMas() {
        System.out.println("横坐标是：" + getX() + " 纵坐标是：" + getY());
    }

    @Override
    public String toString() {
        return "Shape{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}

public class Rect extends Shape{
    private int len;
    private int high;

    public Rect() {
    }

    public Rect(int x, int y, int len, int high) {
        super(x, y);
        setLen(len);
        setHigh(high);
    }

    public int getLen() {
        return len;
    }

    public void setLen(int len) {
        if(len > 0)
            this.len = len;
        else
            System.out.println("长度不能小于零");
    }

    public int getHigh() {
        return high;
    }

    public void setHigh(int high) {
        if(high > 0)
            this.high = high;
        else
            System.out.println("高度不能小于零");
    }

    @Override
    public void printMas() {
        System.out.println("横坐标是：" + getX() + " 纵坐标是：" + getY() + " 长度是：" + getLen()
                            + " 高度是：" + getHigh());
    }

    @Override
    public String toString() {
        return "Rect{" +
                "len=" + len +
                ", high=" + high +
                '}';
    }
}

Shape类表示一个图形，Rect类表示的是圆形，二者之间存在着IS-A的关系，接下来对他们进行测试
首先我们采用创建本类实例的方式，先看一下运行结果：

public class ShapeRectTest {
    public static void main(String[] args) {
        Shape sh = new Shape(10, 26);
        Rect re = new Rect(12,34,56,78);

        sh.printMas(); // 横坐标是：10 纵坐标是：26
        re.printMas(); // 横坐标是：12 纵坐标是：34 长度是：56 高度是：78
}

接下来我们采用多态的方式进行测试：

public class ShapeRectTest {
    public static void main(String[] args) {
        Shape a = new Rect(127, 348, 578, 758);
        //披着羊皮的狼，a具体是什么类型要看后面new的是哪个，因此会调用子类Rect中的printMas()方法
        
        a.printMas(); 
        // 横坐标是：127 纵坐标是：348 长度是：578 高度是：758
    }
}

2.多态的特点

当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调用父类独有的方法。
当父类类型的引用指向子类类型的对象时，父类类型的引用不可以直接调用子类独有的方法。
对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段调用子类重写的版本（动态绑定）。
对于父子类都有的静态方法来说，编译和运行阶段都调用父类版本

3. 类型转换

3.1自动类型转换（向上转型）

上转型在前面已经用到了，就是：Shape a = new Rect(127, 348, 578, 758); 由子类转向为父类

3.2强制类型转换（向下转型）

前面提到，父类类型的引用是不能直接调用子类独有方法的，如果就是想调用，就需要使用强转的方式，示例如下：

public class ShapeRectTest {
    public static void main(String[] args) {
        Shape a = new Rect(127, 348, 578, 758);
        // a.getLen(); 这样写会报错，因为父类不能直接调用子类独有方法，需要强转，如下所示
        int len = ((Rect) a).getLen();
        System.out,println(len); 
    }
}

在进行类型转换时我们必须要注意一个细节，那就是转换必须发生在父子类之间

3.3类型转换要注意的问题

若强转的目标类型并不是该引用真正指向的数据类型时则编译通过，运行阶段发生类型转换异常

public class ShapeRectTest {
    public static void main(String[] args) {
        Shape a = new Rect(127, 348, 578, 758);
        
        //若由一个类ShapeB继承自Shape, 那么下面的写法是错误的。虽然编译时不会报错，但是运行时会出错
        //这是因为 a 虽然是Shape类型的实例，但是在运行时其本质是Rect类，而Rect类和ShapeB类之间不存在继承关系
        ShapeB b = (ShapeB)a; 
    }
}

对此我们的解决方法也很简单，就是使用 instanceof 关键字

public class ShapeRectTest {
    public static void main(String[] args) {
        Shape a = new Rect(127, 348, 578, 758);
        
        // 判断引用变量指向的对象是否为后面的数据类型
        if(a instanceof  ShapeB) { 
        	ShapeB b = (ShapeB)a;
        	a.printMas();
        }
        else {
        	System.out.println("error");
        }
    }
}

4.多态的实际意义

多态的实际意义在于屏蔽不同子类的差异性实现通用的编程带来不同的效果，例如：

public class ShapeTest {

    // 自定义成员方法实现既能打印矩形对象又能打印圆形对象的特征，对象由参数传入  子类 is a 父类
    // Shape s = new Rect(1, 2, 3, 4);   父类类型的引用指向子类类型的对象，形成了多态
    // Shape s = new Circle(5, 6, 7);    多态
    // 多态的使用场合一：通过参数传递形成了多态
    public static void draw(Shape s) {
        // 编译阶段调用父类的版本，运行阶段调用子类重写以后的版本
        s.show();
    }

    public static void main(String[] args) {

        // Rect r = new Rect(1, 2, 3, 4);
        // r.show();
        ShapeTest.draw(new Rect(1, 2, 3, 4));
        ShapeTest.draw(new Circle(5, 6, 7));
    }
}

六、抽象方法与抽象类（与多态结合）

6.1 抽象方法

抽象方法主要指不能具体实现的方法并且使用abstract关键字修饰，也就是没有方法体，例如：

public abstract void printMas();

其语法格式为：访问权限 abstract 返回值类型方法名(形参列表);

6.2 抽象类

抽象类主要指不能具体实例化的类并且使用abstract关键字修饰，也就是不能创建对象，例如：

public abstract class AbstractClass {
	private int count;
	
	public AbstractClass(){}

	public AbstractClass(int count) {
		setCount(count;)
	}
	
	public void setCount(int count) {
	//一般会进行合理性判定，这里省略了
		this.count = count;
	}
	
	public abstract void abstractMethord();
}

6.3 抽象类与抽象方法之间的关系

抽象类中可以有成员变量、构造方法、成员方法；
抽象类中可以没有抽象方法，也可以有抽象方法；
拥有抽象方法的类必须是抽象类，因此真正意义上的抽象类应该是具有抽象方法并且使用abstract关键字修饰的类
抽象类中要包含抽象方法，如果没有那么抽象类不能实例化的意义就不存在了
抽象类有构造方法但不能new对象，但可以让子类通过super()的方式调用构造方法

6.4 个人对抽象类的理解

抽象类的存在不是为了创建对象，而是为了继承，这样的话子类继承抽象类后可以根据所需重写抽象类中的抽象方法
模板设计模式：当一个类继承抽象类后必须重写抽象方法，否则该类也变成抽象类，也就是抽象类对子类具有强制性和规范性
在以后的开发中推荐使用多态的格式，此时父类类型引用直接调用的所有方法一定是父类中拥有的方法，若以后更换子类时，只需要将new关键字后面的子类类型修改而其它地方无需改变就可以立即生效，从而提高了代码的可维护性和可扩展型，示例如下：

public abstract class AbstractTest {
    private int cnt;

    public AbstractTest() {
    }

    public AbstractTest(int cnt) {
        setCnt(cnt);
    }

    public int getCnt() {
        return cnt;
    }

    public void setCnt(int cnt) {
        this.cnt = cnt;
    }

    // 自定义抽象方法
    public abstract void show();
}

public class SubAbstractTest extends AbstractTest {
    @Override
    public void show() {
        System.out.println("对抽象方法的重写");
    }

    public static void main(String[] args) {
        // 声明AbstractTest类型的引用指向子类的对象，形成了多态
        // 多态的使用场合之二： 直接在方法体中使用抽象类的引用指向子类类型的对象
        AbstractTest at = new SubAbstractTest();
        // 编译阶段调用父类版本，运行阶段调用子类版本
        at.show();
    }
}

回想在多态中提到的：多态的实际意义在于屏蔽不同子类的差异性实现通用的编程带来不同的效果。第10行代码中使用了多态，即 AbstractTest 类型的对象指向了 SubAbstractTest 类型的对象，对于多态而言，at 可以直接调用的是父类中已有方法show()，而当我们不想用 SubAbstractTest 类型或者需要更换子类时，我们只需要把 new 后面的子类构造方法换一下就行了，可以实现代码的重用。

七、接口 — 弥补Java语言不支持多继承的不足

首先我们要知道，接口比抽象类还抽象，所有方法都是抽象方法
其次与抽象类不同，抽象类需要被继承 关键字是extends，并且是单继承；而接口则是被实现 关键字是 implements，一个类可以实现多个接口，这也就是标题所说的弥补Java语言不支持多继承的不足
继承抽象类支持单继承，而实现接口支持多实现。
抽象类中可以有构造方法，而接口中不可以有构造方法。
抽象类中可以有成员变量，而接口中只可以有常量
抽象类中可以有成员方法，而接口中只可以有抽象方法。
抽象类中增加方法时子类可以不用重写，而接口中增加方法时实现类需要重写（Java8以前的版本）。
从Java8开始增加新特性，接口中允许出现非抽象方法和静态方法，但非抽象方法需要使用default关键字修饰。
从Java9开始增加新特性，接口中允许出现私有方法。

具体示例如下：

public interface Runner {
    public abstract void run();
}

public interface Hunter extends Runner{
    public abstract void hunt();
}

public class Man implements Hunter{

    @Override
    public void hunt() {
        System.out.println("打猎");
    }

    @Override
    public void run() {
        System.out.println("奔跑");
    }

    public static void main(String[] args) {
        //声明接口类型的引用指向实现类的对象，形成了多态
        Runner r = new Man();
        r.run();
        Hunter h = new Man();
        h.hunt();
    }
}

八、内部类

简单而言，当一个类存在的价值仅仅是为某一个类单独服务时，那么就可以将这个类定义为所服务类中的内部类，这样可以隐藏该类的实现细节并且可以方便的访问外部类的私有成员而不再需要提供公有的get和set方法。其中内部类共有四类，分别是：

普通内部类 - 直接将一个类的定义放在另外一个类的类体中。
静态内部类 - 使用static关键字修饰的内部类，隶属于类层级。
局部内部类 - 直接将一个类的定义放在方法体的内部时。
匿名内部类 - 就是指没有名字的内部类

8.1 普通内部类

普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法、使用 final 或者 abstract 关键字修饰、使用 private 或 protected 关键字进行修饰。

public class NormalOuter {
    private int out = 1;

    public class NormalInner {
        private int in = 2;
        private int out = 3;

        public NormalInner() {
        }

        public void show() {
            System.out.println("内部类out：" + out);
            System.out.println("内部类in：" + in);
        }

        public void show2(int out) {
            System.out.println("形参out：" + out);       //局部优先原则
            System.out.println("内部类out：" + this.out); 	//访问同名变量时，使用this.变量名
            System.out.println("外部类out：" + NormalOuter.this.out);  //访问外部类的变量时，要外部类名.this.变量名
        }
    }
}

public class NormalOuterTest {
    public static void main(String[] args) {
        NormalOuter or = new NormalOuter();
        NormalOuter.NormalInner in = or.new NormalInner(); // 普通内部类需要使用外部类对象来创建对象
        in.show();
        System.out.println("*****************");
        in.show2(4);
    }
}

8.2 静态内部类

静态内部类不能直接访问外部类的非静态成员。
静态内部类可以直接创建对象

/**
 * 实现静态内部类的定义和使用
 */
public class StaticOuter {
    private int cnt = 1;        // 隶属于对象层级
    private static int snt = 2; // 隶属于类层级

    /**
     * 定义静态内部类   有static关键字修饰隶属于类层级
     */
    public static class StaticInner {
        private int ia = 3;
        private static int snt = 4;

        public StaticInner() {
            System.out.println("静态内部类的构造方法哦！");
        }

        public void show() {
            System.out.println("ia = " + ia); // 3
            System.out.println("外部类中的snt = " + snt); // 2
            //System.out.println("外部类的cnt = " + cnt); 
            // Error:静态上下文中不能访问非静态的成员，因此此时可能还没有创建对象
        }

        public void show2(int snt) {  // 就近原则
            System.out.println("snt = " + snt); // 5
            System.out.println("内部类中的成员snt = " + StaticInner.snt); // 4
            System.out.println("外部类中的成员snt = " + StaticOuter.snt); 
            // 2 如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要使用类名.的方式访问
            new StaticOuter().show();
        }
    }
}

public class StaticOuterTest {

    public static void main(String[] args) {

        // 1.声明StaticInner类型的引用指向该类型的对象
        StaticOuter.StaticInner si = new StaticOuter.StaticInner();
        // 2.调用show方法进行测试
        si.show();
        
        si.show2(5);
    }
}

8.3 局部内部类

局部内部类不能使用访问控制符和static关键字修饰符。
局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致

public class AreaOuter {
    private int cnt = 1;

    public void show() {
        // 定义一个局部变量进行测试，从Java8开始默认理解为final关键字修饰的变量
        // 虽然可以省略final关键字，但建议还是加上
        final int ic = 4;

        // 定义局部内部类，局部内部类只能在该方法的内部可以使用
        class AreaInner {
            private int ia = 2;

            public AreaInner() {
            }

            public void test() {
                int ib = 3;
                System.out.println("ia = " + ia); // 2
                System.out.println("cnt = " + cnt); // 1
                //ic = 5;  Error
                System.out.println("ic = " + ic); // 4
            }
        }

        // 声明局部内部类的引用指向局部内部类的对象
        AreaInner ai = new AreaInner();  //局部内部类可以在方法体内部直接创建对象。
        ai.test();
    }

}

8.4 回调模式

回调模式是指——如果一个方法的参数是接口类型，则在调用该方法时，需要创建并传递一个实现此接口类型的对象；而该方法在运行时会调用到参数对象中所实现的方法（接口中定义的）。

public interface AnonymousInterface {
    // 自定义抽象方法
    public abstract void show();
}

public class AnonymousInterfaceImpl implements AnonymousInterface {
    @Override
    public void show() {
        System.out.println("这里是接口的实现类！");
    }
}

public class AnonymousInterfaceTest {
    // 假设已有下面的方法，请问如何调用下面的方法？
    // AnonymousInterface ai = new AnonymousInterfaceImpl(); 接口类型的引用指向实现类型的对象，形成了多态
    public static void test(AnonymousInterface ai) {
        // 编译阶段调用父类版本，运行调用实现类重写的版本
        ai.show();
    }

    public static void main(String[] args) {

        //AnonymousInterfaceTest.test(new AnonymousInterface()); // Error:接口不能实例化
        AnonymousInterfaceTest.test(new AnonymousInterfaceImpl()); //new 一个接口的实现类，再用接口的实现类去调用show()方法（第二行注释的代码便是对这句的解释）
    }
}

8.5 匿名内部类

语法格式：接口/父类类型引用变量名 = new 接口/父类类型() { 方法的重写 };

public class AnonymousInterfaceTest {

    // 假设已有下面的方法，请问如何调用下面的方法？
    // AnonymousInterface ai = new AnonymousInterfaceImpl();
    // 接口类型的引用指向实现类型的对象，形成了多态
    public static void test(AnonymousInterface ai) {
        // 编译阶段调用父类版本，运行调用实现类重写的版本
        ai.show();
    }

    public static void main(String[] args) {
        // 使用匿名内部类的语法格式来得到接口类型的引用，格式为：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
        AnonymousInterface ait = new AnonymousInterface() {
            @Override
            public void show() {
                System.out.println("匿名内部类就是这么玩的，虽然你很抽象！");
            }
        };

        // 从Java8开始提出新特性lamda表达式可以简化上述代码，格式为：(参数列表) -> {方法体}
        AnonymousInterface ait2 = () -> System.out.println("lamda表达式原来是如此简单！");
        AnonymousInterfaceTest.test(ait2);
    }
}

九、枚举类型

使用public static final表示的常量描述较为繁琐，使用enum关键字来定义枚举类型取代常量，枚举类型是从Java5开始增加的一种引用数据类型。
枚举值就是当前类的类型，也就是指向本类的对象，默认使用public static final关键字共同修饰，因此采用枚举类型.的方式调用。
枚举跟普通类一样可以用自己的变量、方法和构造函数，构造函数只能使用 private 访问修饰符，所以外部无法调用。
枚举既可以包含具体方法，也可以包含抽象方法。如果枚举类具有抽象方法，则枚举类的每个实例都必须实现它。
枚举类型要求所有枚举值必须放在枚举类型的最前面

/**
* 如果不使用枚举类型的话我们需要自己编码，如下：
*/
public class Direction {
    private final String desc; // 用于描述方向字符串的成员变量

    // 2.声明本类类型的引用指向本类类型的对象
    public static final Direction UP = new Direction("向上");
    public static final Direction DOWN = new Direction("向下");
    public static final Direction LEFT = new Direction("向左");
    public static final Direction RIGHT = new Direction("向右");

    // 通过构造方法实现成员变量的初始化，更加灵活
    // 1.私有化构造方法，此时该构造方法只能在本类的内部使用
    private Direction(String desc) {
        this.desc = desc;
    }

    // 通过公有的get方法可以在本类的外部访问该类成员变量的数值
    public String getDesc() {
        return desc;
    }
}

接下来我们使用枚举类型，关键字为enum

public interface DirectionInterface {
    // 自定义抽象方法
    public abstract void show();
}

public enum DirectionEnum implements DirectionInterface{
	// 2.声明本类类型的引用指向本类类型的对象
    // 匿名内部类的语法格式：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
    // public static final Direction UP = new Direction("向上") { 方法的重写 };
	UP("向上") {
        @Override
        public void show() {
            System.out.println("贪吃蛇向上移动了一下！");
        }
    }, DOWN("向下") {
        @Override
        public void show() {
            System.out.println("贪吃蛇向下移动了一下！");
        }
    }, LEFT("向左") {
        @Override
        public void show() {
            System.out.println("左移了一下！");
        }
    }, RIGHT("向右") {
        @Override
        public void show() {
            System.out.println("右移了一下！");
        }
    };
	
	private final String desc;
	
	// 通过构造方法实现成员变量的初始化，更加灵活
    // 1.私有化构造方法，此时该构造方法只能在本类的内部使用
	private Direction(String desc) {
        this.desc = desc;
    }
    
	public String getDesc() {
        return desc;
    }
    
    // 整个枚举类型只重写一次，所有对象调用同一个
    /*@Override
    public void show() {
        System.out.println("现在可以实现接口中抽象方法的重写了！");
    }*/
}

枚举类常用方法

在这里插入图片描述

十、注解

注解本质上就是代码中的特殊标记，通过这些标记可以在编译、类加载、以及运行时执行指定的处理
语法格式为：访问修饰符 @interface 注解名称 { 注解成员; }
通过@注解名称的方式可以修饰包、类、成员方法、成员变量、构造方法、参数、局部变量的声明等

//自定义注解MyAnnotation 
import java.lang.annotation.*;

public @interface MyAnnotation {
    //如果注解只有一个参数成员，建议使用参数名为value，而类型只能是八种基本数据类型、String类型、Class类型、enum类型及Annotation类型
    public String value() default "123"; // 声明一个String类型的成员变量，名字为value
    public String value2();
}

@MyAnnotation(value = "hello", value2 = "world")
public class Person { ...... }

元注解

元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面。
元注解主要有 @Retention、@Documented、@Target、@Inherited、 @Repeatable。

10.1 @Retention 应用到一个注解上用于说明该注解的的生命周期

import java.lang.annotation.*;

//@Retention(RetentionPolicy.SOURCE)     // 表示下面的注解在源代码中有效
//@Retention(RetentionPolicy.CLASS)      // 表示下面的注解在字节码文件中有效，默认方式
@Retention(RetentionPolicy.RUNTIME)      // 表示下面的注解在运行时有效 可以使用反射机制看到

// 若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解
public @interface MyAnnotation {
    public String value() default "123"; // 声明一个String类型的成员变量，名字为value
}

10.2 @Documented 用于指定被该注解将被javadoc工具提取成文档

定义为@Documented的注解必须设置Retention值为RUNTIME

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)      // 表示下面的注解在运行时有效
@Documented                              // 表示下面的注解信息可以被javadoc工具提取到API文档中，很少使用

// 若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解
public @interface MyAnnotation {
    public String value() default "123"; // 声明一个String类型的成员变量，名字为value
}

10.3 @Target用于指定被修饰的注解能用于哪些元素的修饰

在这里插入图片描述

import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)      // 表示下面的注解在运行时有效
@Documented                              // 表示下面的注解信息可以被javadoc工具提取到API文档中，很少使用
// 表示下面的注解可以用于类型、构造方法、成员变量、成员方法、参数 的修饰
@Target({ElementType.TYPE, ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
// 若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解
public @interface MyAnnotation {
    public String value() default "123"; // 声明一个String类型的成员变量，名字为value
}

10. 4 @Inherited

import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)      // 表示下面的注解在运行时有效
@Documented                              // 表示下面的注解信息可以被javadoc工具提取到API文档中，很少使用
// 表示下面的注解可以用于类型、构造方法、成员变量、成员方法、参数 的修饰
@Target({ElementType.TYPE, ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
@Inherited  // 表示下面的注解所修饰的类中的注解使用可以被子类继承
// 若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解
public @interface MyAnnotation {
    public String value() default "123"; // 声明一个String类型的成员变量，名字为value
}

10.5 @Repeatable 表示自然可重复的含义，从Java8开始增加的新特性

比如彼得-帕克即是报社摄影师又是蜘蛛侠，这个时候如果注解的值只有一个，但我们想表示两个特性时，需要这么做：

public @interface ManType {
    String value() default "";
}

public @interface ManTypes {
    ManType[] value();
}

@ManTypes({@ManType(value = "职工"), @ManType(value = "超人")})  // 在Java8以前处理多个注解的方式
public class Man { ...... }

而在Java8引入新特性之后我们可以这么写：

@Repeatable(value = ManTypes.class)
public @interface ManType {
    String value() default "";
}

@ManType(value = "职工")
@ManType(value = "超人")
public class Man { ...... }

补充：

从Java8开始对元注解@Target的参数类型ElementType枚举值增加了两个：

其中ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明
语句中，如：泛型。
其中ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中

总结

坚持学完之后做一做总结，进行复习！
2022.2.9 22：50完成

JavaSE学习小结

JavaSE学习小结

文章目录

一、封装的概念与示例

二、构造快 与 静态代码块

1.构造块：在类体中直接使用{}括起来的代码块。

2.静态代码块：使用static关键字修饰的构造块。

3.构造块 与 静态代码块的笔试考点

三、单例设计模式

饿汉式创建单例对象

懒汉式创建单例对象

进一步优化： 针对线程安全的优化（目前自身能力只能考虑到这里了）

四、final关键字

五、多态

1. 多态的概念

2.多态的特点

3. 类型转换

3.1自动类型转换 （向上转型）

3.2强制类型转换 （向下转型）

3.3类型转换要注意的问题

4.多态的实际意义

六、抽象方法 与 抽象类 （与多态结合）

6.1 抽象方法

6.2 抽象类

6.3 抽象类与抽象方法之间的关系

6.4 个人对抽象类的理解

七、接口 — 弥补Java语言不支持多继承的不足

八、内部类

8.1 普通内部类

8.2 静态内部类

8.3 局部内部类

8.4 回调模式

8.5 匿名内部类

九、枚举类型

枚举类常用方法

十、注解

元注解

10.1 @Retention 应用到一个注解上用于说明该注解的的生命周期

10.2 @Documented 用于指定被该注解将被javadoc工具提取成文档

10.3 @Target用于指定被修饰的注解能用于哪些元素的修饰

10. 4 @Inherited

10.5 @Repeatable 表示自然可重复的含义，从Java8开始增加的新特性

补充 ：

总结

二、构造快与静态代码块

3.构造块与静态代码块的笔试考点

进一步优化：针对线程安全的优化（目前自身能力只能考虑到这里了）

3.1自动类型转换（向上转型）

3.2强制类型转换（向下转型）

六、抽象方法与抽象类（与多态结合）

补充：