1 final关键字的使用

  final主要就是表示不能修改的意思，可以修饰在变量，方法和类上，下面我们将分别讨论修饰后的效果。

1.1 修饰变量

/**
 * final关键字的使用：修饰变量
 */
public class Demo1 {
    public static void main(String[] args) {
        // 第1种情况：
        //final修饰一个变量，变量的值不可以改变，这个变量也变成了一个字符常量，约定俗称的规定：名字大写
        final int A = 10;//final修饰基本数据类型
        //A = 20; 报错：不可以修改值

        // 第2种情况：
        final Dog dog = new Dog(); // final修饰引用数据类型，那么地址值就不可以改变
        //dog = new Dog(); -->地址值不可以更改
        //dog对象的属性依然可以改变：
        dog.age = 10;

        // 第3种情况：
        final Dog d2 = new Dog();
        a(d2);

        //第4种情况：
        b(d2);
    }

    public static void a(Dog d){
            d = new Dog();
    }

    public static void b(final Dog d){ // d被final修饰 ，指向不可以改变
//            d = new Dog(); // 报错
    }
}

class Dog {
    int age;
    int weight;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

1.2 修饰方法

  final修饰方法，那么这个方法不可以被该类的子类重写：

1.3 修饰类

  final修饰类，代表没有子类，该类不可以被继承：一旦一个类被final修饰，那么里面的方法也没有必要用final修饰了（final可以省略不写）

1.4 案例：JDK提供的Math类

 &emsp看源码发现：

  1. 因为Math类在java.lang包下，所以使用Math类的时候无需导包，直接使用即可。
  2. Math类被final修饰，所以不能被其他类继承了。
  3. 因为类被final修饰，所以里面的所有属性和方法都隐藏被final修饰，只是省略不写了（原因：没有子类，没有必要进行重写。）
  4. 发现Math类中的所有的属性，方法都被static修饰，那么不用创建对象去调用，只能通过类名.属性名 类名.方法名 去调用
  5. 外界不可以创建对象：

Math m = new Math();//报错
1

2 abstract关键字的使用

  abstract的主要含义就是抽象，不可以实例化的意思，一般修饰在类和方法上，表示抽象类。下面我们来讨论。

（1）抽象类和抽象方法的关系：抽象类中可以定义0-n个抽象方法。

（2）抽象类的作用：

  在抽象类中定义抽象方法，目的是为了为子类提供一个通用的模板，子类可以在模板的基础上进行开发，先重写父类的抽象方法，然后可以扩展子类自己的内容。抽象类设计避免了子类设计的随意性，通过抽象类，子类的设计变得更加严格，进行某些程度上的限制。使子类更加的通用。

（3）抽象类不能创建对象，那么抽象类中是否有构造器？

  抽象类中一定有构造器。构造器的作用 给子类初始化对象的时候要先super调用父类的构造器。

（4）抽象类是否可以被final修饰？

  不能被final修饰，因为抽象类设计的初衷就是给子类继承用的。要是被final修饰了这个抽象类了，就不存在继承了，就没有子类。

代码实例：

/**
 * abstract关键字的使用
 */
//4.一个类中如果有方法是抽象方法，那么这个类也要变成一个抽象类。
//5.一个抽象类中可以有0-n个抽象方法
abstract class Person {
    //1.在一个类中，会有一类方法，子类对这个方法非常满意，无需重写，直接使用
    public void eat(){
        System.out.println("一顿不吃饿得慌");
    }
    //2.在一个类中，会有一类方法，子类对这个方法永远不满意，会对这个方法进行重写。
    //3.一个方法的方法体去掉，然后被abstract修饰，那么这个方法就变成了一个抽象方法
    public abstract void say();
    public abstract void sleep();
}
//6.抽象类可以被其他类继承：
//7.一个类继承一个抽象类，那么这个类可以变成抽象类
//8.一般子类不会加abstract修饰，一般会让子类重写父类中的抽象方法
//9.子类继承抽象类，就必须重写全部的抽象方法
//10.子类如果没有重写父类全部的抽象方法，那么子类也可以变成一个抽象类。
class Student extends Person{
    @Override
    public void say() {
        System.out.println("我是东北人，我喜欢说东北话。。");
    }
    @Override
    public void sleep() {
        System.out.println("东北人喜欢睡炕。。");
    }
}
public class Demo2{
    public static void main(String[] args) {
        //11.创建抽象类的对象：-->抽象类不可以创建对象
        //Person p = new Person();
        //12.创建子类对象：
        Student s = new Student();
        s.sleep();
        s.say();

        //13.多态的写法：父类引用只想子类对象：
        Person p  = new Student();
        p.say();
        p.sleep();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45