final关键字#

• 修饰类：该类称为最终类，特点是不能被继承了。

  用处：修饰工具类

• 修饰方法：该方法称为最终方法，特点是不能被重写了。

• 修饰变量：该变量有且仅能被赋值一次。

  一般修饰静态成员变量和局部变量，而不修饰实例成员变量（没意义）

修饰变量的注意：

• final修饰基本类型的变量，变量存储的数据不能被改变。
• final修饰引用类型的变量（数组、对象），变量存储的地址不能被改变，但地址所指向对象的内容是可以被改变的。

常量#

• 使用static final修饰的成员变量被称为常量。
• 作用：常用于记录系统的配置信息。
• 命名规范：使用大写英文字母，多个单词使用下划线连接起来。

优势：

• 代码可读性好，可维护性好。
• 程序编译后，常量会被“宏替换”：出现常量的地方全部会被替换为其存储的字面量，这样可以保证使用常量和直接使用字面量的性能是一样的。

单例类（设计模式）#

架构师层面的技术。

• 设计模式：一个问题通常有n种解法，其中有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。
• 设计模式有20种，对应20多种软件开发中会遇到的问题。
• 主要学什么：
  • 解决什么问题？
  • 怎么写设计模式？

单例设计模式：

作用：确保某个类只能创建一个对象。

形式：

• 饿汉式单例：在获取类的对象时，对象以及创建好了
  • 写法：
    • 把类的构造器私有。
    • 定义一个类变量记住类的一个对象。
    • 定义一个类方法，返回对象。
• 懒汉式单例：拿对象时，才开始创建对象
  • 写法：
    • 把类的构造器私有。
    • 定义一个私有静态变量用于存储对象。
    • 定义一个静态方法，保证返回的是同一个对象。
• 优缺点：
  • 饿汉式单例占内存，懒汉式单例第一次加载慢

好处：

• 在某些业务场景下，使用单例模式，可以避免浪费内存

1
public class A {
2
    // 2. 私有静态变量
3
    private static A a = new A();
4

5
    // 1. 构造器私有
6
    private A() {
7
    }
8

9
    // 3. 静态方法，保证返回的是同一个对象
10
    pubilc static A getInstance() {
11
        return a;
12
    }
13
}

1
A a1 = A.getInstance();

1
public class B {
2
    // 2. 定义一个类变量记住类的一个对象
3
    // 写法1 final防止被篡改
4
    //public static final A a = new A();
5
    // 写法2
6
    private static B b;
7

8
    // 1. 构造器私有
9
    private B() {
10
    }
11

12
    // （对应写法2）定义一个类方法，返回对象
13
    pubilc static B getInstance() {
14
        if (b == null) {
15
            b = new B();
16
        }
17
        return b;
18
    }
19
}

枚举类#

写法：

1
修饰符 enmu 枚举类名 {
2
    名称1, 名称2, ... ;
3
    其他成员
4
}

特点：

• 枚举类都是最终类，不可以被继承，枚举类都是继承java.lang.Enum类的。

• 枚举类中的第一行，只能写枚举类的对象名称，且要用逗号隔开。

• 这些名称，本质是常量，每个常量都记住了枚举类的一个对象。

• 枚举类的构造器是私有的（写不写都只能是私有的），因此，枚举类对外不能创建对象。（多例类）

  这样写就是单例类了：

  1
  public enum A {
  2
      X;
  3
  }

• 编译器为枚举类新增了几个方法。

示例：

1
// 枚举类 A.java
2
public enum A {
3
    X, Y, Z;
4
}

为了看到枚举类的真实面貌，需要编译—反编译：

• 编译：javac A.java

• 反编译：javap A.class

  1
  Compiled from "A.java"
  2
  public final class A extends java.lang.Enum<A> {
  3
    public static final A X = new A();
  4
    public static final A Y = new A();
  5
    public static final A Z = new A();
  6
    public static A[] values();
  7
    public static A valueOf(java.lang.String);
  8
    static {};
  9
  }

使用：

1
A a1 = A.X;
2
System.out.println(a1); // X
3
A a2 = A.X;
4
System.out.println(a2); // Y
5

6
System.out.println(a1.name()); // X
7
System.out.println(a2.name()); // Y
8
System.out.println(a1.ordinal()); // 索引 0
9
System.out.println(a2.ordinal()); // 索引 1

1
public class Constant {
2
    public static final int UP = 0;
3
    public static final int DOWN = 1;
4
    public static final int LEFT = 2;
5
    public static final int RIGHT = 3;
6
}

1
public static void main(String[] args) {
2
    move(Constant.UP);
3
    move(100); // 缺点：参数值不受约束，这样写没有意义
4
}
5

6
public static void move(int direction) {
7
    switch (direction) {
8
        case Constant.UP:
9
            System.out.println("向上移动");
10
            break;
11
        case Constant.DOWN:
12
            System.out.println("向下移动");
13
            break;
14
        ...
15
        default:
16
            System.out.println("输入有误");
17
    }
18
}

1
public class Direction {
2
    UP, DOWN, LEFT, RIGHT;
3
}

1
public static void main(String[] args) {
2
    move(Direction.UP); // 只能用枚举类
3
}
4

5
public static void move(Direction direction) {
6
    switch (direction) {
7
        case Direction.UP:
8
            System.out.println("向上移动");
9
            break;
10
        case DOWN: // 可以省略Direction
11
            System.out.println("向下移动");
12
            break;
13
        case LEFT:
14
            System.out.println("向左移动");
15
            break;
16
        case RIGHT:
17
            System.out.println("向右移动");
18
            break;
19
    }
20
}

抽象类#

abstract关键字

• 修饰类，就是抽象类。
• 修饰方法，就是抽象方法。只有方法签名，不能有方法体

注意事项：

• 抽象类中不一定要有抽象方法，有抽象方法的类必须是抽象类。
• 类有的成员（成员变量、方法、构造器）抽象类都可以有。
• 抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
• 一个类继承抽象类，必须重写完抽象父类的全部抽象方法，否则这个类也必须定义为抽象类。

1
public abstract class A {
2
    public abstract void test();
3
}

好处：

• 父类知道每个子类都要做某个行为，但每个子类要做的情况不一样，父类就定义成抽象方法，交给子类去重写实现。设计这样的类就是为了更好的支持多态。

1
public abstract class person {
2
    public void write() {
3
        System.out.println("标题");
4
        // 正文 给子类自己实现
5
        writeMain();
6
        System.out.println("结尾");
7
    }
8

9
    public abstract void writeMain();
10
}

接口#

interface关键字

• 接口不能创建对象
• 接口是用来被类实现（inplements）的，实现接口的类称为实现类，一个类可以同时实现多个接口。
• 实现类实现多个接口时，必须实现全部接口的抽象方法，否则必须定义为抽象类。

1
public interface 接口名 {
2
    // 成员变量（常量）
3
    // 成员方法（抽象方法）
4
}

• 常量：接口中定义常量可以省略public static final，默认会加上
• 抽象方法：接口中定义抽象方法可以省略public abstract。

1
public interface A {
2
    // public static final String NAME = "黑马";
3
    String NAME = "黑马";
4

5
    // public abstract void run();
6
    void run();
7
}

1
public class C implements A,B {
2
    ...
3
}
4
public class D implements A {
5
    ...
6
}

1
A a1 = new C();
2
A a2 = new D();

好处：

• 弥补了类单继承的不足，一个类同时可以实现多个接口，使类的角色更多，功能更强大。
• 让程序可以面向接口编程，这样程序员就可以灵活方便地切换各种业务实现（更便于程序的解耦合）。

1
public interface A {
2
    default void test1() {
3
        ...
4
    }
5
    private void test2() {
6
        ...
7
    }
8
    static void test3() {
9
        ...
10
    }
11
}

抽象类Vs接口的区别#

相同点：

1. 都是抽象形式：都可以有抽象方法，都不能创建对象。
2. 都是派生子类形式：抽象类是被子类继承使用，接口是被实现类实现。
3. 一个类继承抽象类，或者实现接口，都必须重写完它们的抽象方法，否则自己要成为抽象类。
4. 都能支持多态，都能实现解耦合。

不同点：

1. 抽象类中可以定义类的全部普通成员，接口只能定义常量、抽象方法（、JDK8后新增的三种方式）。
2. 抽象类只能被类单继承，接口可以被类多实现。
3. 一个类继承抽象类就不能再继承其他类，一个类实现类接口还可以继承其他类或实现其他接口。
4. 抽象类体现模板思想：更利于做父类，实现代码的复用性。
5. 接口更适合做功能的解耦合：解耦合性更强更灵活。

代码块#

类中5大成分：成员变量、构造器、方法、代码块、内部类。

静态、实例代码块

1
public class StaticBlock {
2
    public static String[] cards = new String[54];
3

4
    public static void main(String args[]) {
5
        System.out.println("--main--");
6
    }
7
    static {
8
        System.out.println("--static--");
9
        cards[0] = "A";
10
        cards[1] = "B";
11
        ...
12
    }
13
}
14
// --static--
15
// --main--

1
public class InstanceBlock {
2
    public String[] cards = new String[54]; // 不加static是实例变量
3

4
    {
5
        System.out.println("--Instance--");
6
        cards[0] = "A";
7
        cards[1] = "B";
8
        ...
9
    }
10
    public static void main(String args[]) {
11
        System.out.println("--main--");
12
        new InstanceBlock();
13
    }
14
}
15
// --main--
16
// --Instance--

内部类#

• 如果一个类定义在另一个类内部，这个类就是内部类。
• 场景：当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。

1
public class Outer {
2

3
    public class Inner {
4
        ...
5
    }
6
}

1
// 使用
2
Outer.Inner oi = new Outer().new Inner();

1
public class Outer {
2

3
    public static class Inner {
4
        ...
5
    }
6
}

1
// 使用
2
Outer.Inner oi = new Outer.Inner();

1
public class Test {
2

3
    public static void go() {
4
        class Local1 {
5
            ...
6
        }
7
        abstract class Local2 {
8
            ...
9
        }
10
        interface Local3 {
11
            ...
12
        }
13
    }
14
}

1
new 类活接口(参数值...) {
2
    类体（一般是方法重写）
3
};

1
public abstract class Animal {
2
    public abstract void cry();
3
}

1
public class HelloWorld {
2
    public static void main(String[] args) {
3

4
        Animal a = new Animal() {
5
            @Override
6
            public void cry() {
7
                System.out.println("miao~");
8
            }
9
        };
10
    }
11
}

1
public class HelloWorld {
2
    public static void main(String[] args) {
3

4
        Swin student = new Student();
5
        start(student);
6
    }
7

8
    public static void start(Swin swin) {
9
        swin.swining();
10
    }
11
}
12

13
class Teacher implements Swin {
14
    @Override
15
    public void swining() {
16
        System.out.println("老师游泳");
17
    }
18
}
19

20
class Student implements Swin {
21
    @Override
22
    public void swining() {
23
        System.out.println("学生游泳");
24
    }
25
}
26
interface Swin {
27
    void swining();
28
}

1
public class HelloWorld {
2
    public static void main(String[] args) {
3

4
        // 写法1
5
        Swin student = new Swin() {
6
            @Override
7
            public void swining() {
8
                System.out.println("学生游泳");
9
            }
10
        };
11
        start(student);
12

13
        // 写法2
14
        start(new Swin() {
15
            @Override
16
            public void swining() {
17
                System.out.println("老师游泳");
18
            }
19
        });
20
    }
21

22
    public static void start(Swin swin) {
23
        swin.swining();
24
    }
25
}
26

27
interface Swin {
28
    void swining();
29
}

1
public static void main(String[] args) {
2

3
    // 创建一个登录窗口，窗口上只有一个登录按钮
4
    JFrame win = new JFrame();
5
    win.setSize(300, 200);
6
    win.setTitle("登录窗口");
7
    win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 点击×时退出程序
8

9
    JPanel p = new JPanel();
10
    JButton btn = new JButton("登录");
11

12
    p.add(btn);
13
    win.add(p);
14

15
    btn.addActionListener(new AbstractAction() {
16
        @Override
17
        public void actionPerformed(ActionEvent e) {
18
            System.out.println("登录按钮被点击了");
19
        }
20
    });
21
    //btn.addActionListener(e -> {
22
    //    System.out.println("登录");
23
    //});
24
    //btn.addActionListener(e -> System.out.println("登录"));
25
    win.setVisible(true);
26
}

1
public static void main(String[] args) {
2
    Student[] students = new Student[5];
3
    students[0] = new Student("张三", 18);
4
  ...
5

6
    // 按年龄升序排序
7
    // public static <T> void sort(T[] a, Comparator<? super T> c)
8
    // Comparator是一个接口，需要实现compare方法
9
    Arrays.sort(students, new Comparator<Student>() {
10
        @Override
11
        public int compare(Student o1, Student o2) {
12
            // 如果左边 > 右边，需要返回正整数
13
            // 左边 < 右边，返回负整数
14
            // 左边 == 右边，返回0
15
            return o1.getAge() - o2.getAge();
16
        }
17
    });
18

19
    // Arrays.sort(students, (o1, o2) -> o1.getAge() - o2.getAge());
20
}

函数式编程#

• 此“函数”类似于数学中的函数（强调做什么）。

1
(被重写方法的形参列表) -> {
2
  被重写方法的方法体
3
}

1
public class HelloWorld {
2
    public static void main(String[] args) {
3
        Swim swim = () -> {
4
                System.out.println("游泳");
5
        };
6
    }
7

8
}
9
@FunctionalInterface
10
interface Swim {
11
    void swimming();
12
}

1
类名::静态方法

1
// Student类的静态方法
2
public static int compareAge(Student s1, Student s2){
3
    return s1.age - s2.age;
4
}

1
// Arrays.sort(students, (s1, s2) -> Student.compareAge(s1, s2));
2

3
Arrays.sort(students, Student::compareAge);

1
对象名::实例方法

1
// Student类的实例方法
2
public int compareAge(Student s1, Student s2){
3
    return s1.age - s2.age;
4
}

1
Student t = new Student();
2
//  Arrays.sort(students, (s1, s2) -> t.compareAge(s1, s2));
3

4
Arrays.sort(students, t::compareAge);

1
特定类的名称::方法

1
String[] names = {"Jack", "Rose", "Tom", "jrry", "Lucy", "Mary"};
2
// Arrays.sort(names, (s1, s2) -> s1.compareToIgnoreCase(s2));
3
Arrays.sort(names, String::compareToIgnoreCase);

1
类名::new

1
interface Factory<P> {
2
    Car getCar(String name);
3
}
4
@Data
5
@AllArgsConstructor
6
class Car {
7
    private String name;
8
}

1
public static void main(String[] args) {
2

3
    // 写法1
4
    Factory factory1 = new Factory() {
5
        @Override
6
        public Car getCar(String name) {
7
            return new Car(name);
8
        }
9
    };
10
    // 写法2
11
    Factory factory2 = name -> new Car(name);
12
    // 构造器引用
13
    Factory factory3 = Car::new;
14
}

String#

方式一：Java程序中的所有字符串文字（例如“abc”）都为此类的对象。

1
String str = "hello world";
2
System.out.println(str.length()); // 11

方式二：调用String类的构造器初始化字符串对象。

1
// 都不推荐
2
String str2 = new String(); // String str3 = "";
3
String str4 = new String("hello world");
4

5
// 有时候会用到要转成字符串
6
char[] chars = {'a', 'b', 'c'};
7
String str5 = new String(chars);
8

9
byte[] bytes = {97, 98, 99};
10
String str6 = new String(bytes);

区别：

• 只要是以双引号方式写出的字符串对象，会存储到字符串常量池（堆中），且相同的字符串只存储一份。

  1
  String str = "hello world";
  2
  String str2 = "hello world";
  3
  System.out.println(str == str2); // true

• 通过new方式创建的字符串对象，每new一次都会产生一个新的对象放在堆内存中。

注意：

字符串对比时，使用==比较的是地址，一般是用equal方法，只比较内容：

1
str.equals(str2)

ArrayList动态数组#

是一个集合（动态数组）。

• 数组定义完并启动后，长度就固定了。
• 集合大小可变，功能丰富，开发中用的多。

常用的Swing组件#

• JFrame：窗口
• JPanel：用于组织其他组件的容器
• JButton：按钮组件
• JTextField：输入框
• JTable：表格
• …

常用的布局管理器#

布局管理器：可以决定组件在容器中的布局方式，避免了手动设置每个组件的位置和大小，从而简化了GUI设计过程。

• FlowLayout：水平布局
• BorderLayout：四角和中间布局
• GridLayout：网格布局
• BoxLayout：X和Y轴布局（Y——竖着）

事件处理#

事件处理是通过事件监听器（Event Listener）来完成的

• 点击事件监听器 ActionListener

• 按键事件监听器 KeyListener

  • 要让窗口成为焦点，否则无法监听键盘事件:jf.requestFocus();

    1
    jf.addKeyListener(new KeyAdapter() {
    2
    @Override
    3
    public void keyPressed(KeyEvent e) {
    4
        int keyCode = e.getKeyCode();
    5
        if (keyCode == KeyEvent.VK_UP) {
    6
            System.out.println("向上");
    7
        }else if (keyCode == KeyEvent.VK_DOWN) {
    8
            System.out.println("向下");
    9
        } else if (keyCode == KeyEvent.VK_LEFT) {
    10
            System.out.println("向左");
    11
        } else if (keyCode == KeyEvent.VK_RIGHT) {
    12
            System.out.println("向右");
    13
        }
    14
    }
    15
    });
    16
    
    17
    jf.setVisible(true);
    18
    // 让窗口成为焦点，否则无法监听键盘事件
    19
    jf.requestFocus();

    展开收起

• 鼠标行为监听器 MouseListener

• …

事件的几种常见写法#

1. 直接提供实现类，用于创建事件监听对象。

   1
   // 点击事件监听
   2
   jb.addActionListener(new MyActionListener(jf));

   1
   class MyActionListener implements ActionListener {
   2
       private JFrame jf;
   3
       public MyActionListener(JFrame jf) {
   4
           this.jf = jf;
   5
       }
   6
       @Override
   7
       public void actionPerformed(ActionEvent e) {
   8
           JOptionPane.showMessageDialog(jf, "点击了登录按钮"); // 弹窗
   9
       }
   10
   }

2. 直接使用匿名内部类的对象，代表事件监听对象。

   1
   jb.addActionListener(new AbstractAction() {
   2
   @Override
   3
   public void actionPerformed(ActionEvent e) {
   4
       JOptionPane.showMessageDialog(jf, "点击了登录按钮");
   5
   }
   6
   });

3. 自定义窗口，让窗口对象实现事件接口（让界面本身成为事件监听器对象）。每个界面都是独立的对象，更优雅。

   1
   class LoginFrame extends JFrame implements ActionListener{
   2
       private JButton loginButton;
   3
   
   4
       public LoginFrame(){
   5
           init();
   6
           // setVisible(true);
   7
       }
   8
   
   9
       private void init(){
   10
           setTitle("登录界面");
   11
           setSize(400,300);
   12
           setLocationRelativeTo(null);
   13
           setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
   14
   
   15
           JPanel panel = new JPanel();
   16
           loginButton = new JButton("登录");
   17
           loginButton.addActionListener(this); // 添加监听器（this本身是ActionListener）
   18
   
   19
           panel.add(loginButton);
   20
           this.add(panel);
   21
       }
   22
       @Override
   23
       public void actionPerformed(ActionEvent e) {
   24
           JOptionPane.showConfirmDialog(this, "欢迎回来");
   25
       }
   26
   }

   展开收起

   1
   public class HelloWorld {
   2
       public static void main(String[] args) {
   3
           LoginFrame loginFrame = new LoginFrame();
   4
           loginFrame.setVisible(true);
   5
       }
   6
   }