Javase 基础入门 —— 06 final + 单例

本系列为笔者学习Javase的课堂笔记，视频资源为B站黑马程序员出品的《黑马程序员Java+AI智能辅助编程全套视频教程，java零基础入门到大牛一套通关》，章节分布参考视频教程，为同样学习Javase系列课程的同学们提供参考。

01 final 关键字

final关键字意为最终，其可修饰类、方法、变量。

• 修饰类：该类被称为最终类，特点是不能被继承了
• 修饰方法：该方法被称为最终方法，特点是不能被重写了
• 修饰变量：特点是有且仅能被赋值一次

public class Test{
    //3.修饰变量不能被重赋值
        /*
        	变量有哪些呢？
        	a. 成员变量
        		静态成员变量
        		实例成员变量
        	b. 局部变量
        */
    //静态成员变量 = 常量，其通常作为系统配置信息，名称全部大写
    public static final String SCHOOLNAME = "黑马程序员"; 
    
    //实例成员变量
    private final String name = "孙行者";
    
    public static void main(String[] args){ 
        //局部变量
        final double rate = 3.14;
        //rate = 3.16;
    }
}

//1.修饰类不能被继承
final class A{}
//class B extends A{}

//2.修饰方法不能被重写
class C{
    public final void show(){
        SyStem.out.println("show方法被执行");
    }
}

class D extends C{
//    public void show(){
//        SyStem.out.println("show方法被执行");
//    }
}

注：① final修饰基本类型的变量，变量存储的数据不能被改变。

② final修饰引用类型的变量，变量存储的地址不能被改变。

02 常量

Constant.java

public class Constant{
	public static final String SCHOOLNAME = "黑马程序员";  
} 

03 设计模式

一个问题通常有种解法，其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式，设计模式有20多种，对应20多种软件开发中会遇到的问题。

关于设计模式，主要学习其解决什么问题？以及怎么写？

04 单例设计模式

单例设计模式确保某个类只能创建一个对象。

实现步骤

• 私有化类的构造器
• 定义一个类变量，记住类的一个对象
• 定义一个类方法，返回对象

public class Test{
    public static void main(String[] args){
        A a1 = A.getInstance();
        A a2 = A.getInstance(); //a1 = a2
    }
}

A.java和B.java

//饿汉式单例：拿对象时，对象早就创建好了
public class A{
    private static A a = new A(); //2
    
    private A(){} //1
    
    public static A getInstance(){
        return a; //3
    }
}

//懒汉式单例：拿对象时，开始创建对象了
public class B{
    private static B b; //2
    
    private B(){} //1
    
    public static B getInstance(){
        if(b == null) b = new B();
        return b; //3
    }
}

05 枚举类

A.java

public enum A {
    X, Y, Z;
}

反编译源码

Compiled from "A.java"
public final class A extends java.lang.Enum<A> {
    public static final A X = new A();
    public static final A Y = new A();
    public static final A Z = new A();
    
    public static A[] values();
    public static A valueOf(java.lang.String);
}

Test.java

package finaldemo;

public class Test {
    public static void main(String[] args) {
        A a1 = A.X;
        System.out.println(a1); //toString()方法重写

        A a2 = A.Y;
        System.out.println(a2);

        System.out.println(a1.name()); //名称
        System.out.println(a2.name());
        System.out.println(a1.ordinal()); //索引
        System.out.println(a2.ordinal());
    }
}

• 枚举类不可以被继承（final）
• 枚举类不可以创建对象（构造函数为private）

枚举类适合做信息分类和标志。

Direction.java

public enum Direction {
    UP, DOWN, LEFT, RIGHT;
}

Test2.java

public class Test2 {
    public static void main(String[] args) {
        move(Direction.UP);
        move(Direction.DOWN);
        move(Direction.LEFT);
        move(Direction.RIGHT);
    }

    public static void move(Direction direction){
        switch (direction){
            case Direction.UP :
                System.out.println("向上移动");
                break;
            case Direction.DOWN :
                System.out.println("向下移动");
                break;
            case Direction.LEFT :
                System.out.println("向左移动");
                break;
            case Direction.RIGHT :
                System.out.println("向右移动");
                break;
        }
    }
}

06 抽象类

abstract意为抽象，修饰类作为抽象类，修饰方法作为抽象方法。

A.java

public abstract class A {
    //抽象方法
    //必须用abstract修饰，且没有方法体，只有方法声明
    public abstract void show();
}

B.java

public class B extends A{
    //具体方法
    @Override
    public void show() {
        System.out.println("B类重写show方法");
    }
}

• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
• 类中有的成员抽象类也有，包括成员变量、成员方法、构造器
• 抽象类不可以创建对象，可以被继承

注：一个类继承抽象类，必须重写完抽象类的所有抽象方法，否则该类也要被定义为抽象类。

Test.java

public class Test {
    public static void main(String[] args) {
        B b = new B();
        b.show();
    }
}

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

Animal.java

public abstract class Animal {
    public abstract void cry(); //0个人关心内容
}

Cat.java

public class Cat extends Animal{
    @Override
    public void cry(){
        System.out.println("喵喵喵");
    }
}

Dog.java

public class Dog extends Animal{
    @Override
    public void cry(){
        System.out.println("汪汪汪");
    }
}

Test.java

public class Test {
    public static void main(String[] args) {
        //多态
        Animal a1 = new Cat();
        a1.cry();

        Animal a2 = new Dog();
        a2.cry();
    }
}

07 模板方法设计模式

提供一个方法作为完成某类功能的模板，该方法封装了每个实现步骤，但允许子类提供特定步骤的实现，其可以提高代码的复用性，并简化子类设计。

People.java

public abstract class People {
    public final void write(){ //final无法被重写
        System.out.println("大家好");
        writeMid();
        System.out.println("谢谢大家");
    }

    public abstract void writeMid();
}

Teacher.java

public class Teacher extends People{
//    public void write(){
//        System.out.println("大家好");
//        System.out.println("我系渣渣辉");
//        System.out.println("谢谢大家");
//    }
    @Override
    public void writeMid() {
        System.out.println("我系渣渣辉");
    }
}

Student.java

public class Student extends People{
//    public void write(){
//        System.out.println("大家好");
//        System.out.println("我系奶龙");
//        System.out.println("谢谢大家");
//    }
    @Override
    public void writeMid() {
        System.out.println("我系奶龙");
    }
}

Test.java

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        s.write();

        Teacher t = new Teacher();
        t.write();
    }

}