Java基础之继承、多态、抽象类

Java基础

1.猜数字小游戏

import java.util.Random;
import java.util.Scanner;

public class MathTest {
    public static void main(String[] args) {

        // 猜数字小游戏
        //int randomValue = (int) (Math.random() * 100 + 1); 随机产生[1,101)之间的整数
        Random random = new Random(10);  // 给定一个固定的随机种子，那么其随机值就固定了 ...
        int randomValue = random.nextInt(100) + 1;

        // 对于该对象可以重复使用，所以不需要在While中每次循环重新创建
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.println("请输入一个值:");
            int data = scanner.nextInt();
            if (data == randomValue) {
                System.out.println("恭喜您猜对了...");
                break;
            } else if (data > randomValue) {
                System.out.println("猜的数值过大，请重新输入...");
            } else {
                System.out.println("猜的数值过小，请重新输入...");
            }
        }
    }
}
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

2.代码块

import java.util.Random;

public class CodeType {
    public static void main(String[] args) {
        /*
        在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
            局部代码块
            在方法中出现；限定变量生命周期，及早释放，提高内存利用率
            构造代码块
            在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
            静态代码块 在类中方法外出现，加了static修饰
            在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且值执行一次。

         */

        useCodeRound();

        Student student = new Student("李白", 18);
        student.show();
        Student student1 = new Student("苏轼", 18);
        student1.show();
        Student student2 = new Student("杜甫", 18);
        student2.show();
//        Student student = new Student("孟浩然", 18);;


    }

    public static void useCodeRound() {
        int i = 10;
        // TODO 局部代码块: 在方法中使用 {} 定义 => 其作用是用于限制变量的生命周期
        {
            int var = 1;
            System.out.println(var);
            System.out.println(i);
        }
//        System.out.println(var);  // TODO 局部代码块中定义的变量其作用范围仅在当前{}中 {}执行完成，变量消失
        System.out.println(i);  //


    }
}

class Student {
    private static String flag ;  // flag标记 当出现在Student中用于标记当前类是一个人类
    /*
        TODO 静态代码块：
            定义：在类中 方法外 使用 static修饰 {}
            作用：在类被加载时，用于创建对象之前，静态代码块会被执行
            应用：对静态变量进行做初始化 => 对类做初始化
     */
    static {
        System.out.println("人类被上帝所赋予了...");
        flag = "人类";
    }


    private String name;
    private int age;
    private String skill;

    /*
        TODO 构造代码块：
            定义：在类中 方法外使用 {} 定义
            作用：在对象每次被构建时，都会被执行, 并且构造代码块会先于构造方法执行
            应用场景: 对于对象构建时，进行做初始化操作 => 对对象进行初始化
     */
    {
        System.out.println("一个新生命产生了,上帝赋予了天赋");
        int nextInt = new Random().nextInt(3);// 0 1 2
        if (nextInt == 0){
            this.skill = "高智商";
        }else if (nextInt == 1){
            this.skill = "高情商";
        }else {
            this.skill = "高财商";
        }
    }

    public Student(String name, int age) {
        System.out.println("Student构造方法被调用了...");
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }

    public void show() {
        System.out.println(flag+":姓名：" + name + "\t 年龄:" + age + "\t 天赋：" + skill );
    }
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

3.继承

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

public class Extend {
    public static void main(String[] args) {
        /*
            TODO 继承关系
                当在Java中编写代码时，有时两个类直接存在一些逻辑上的关系，同时有一些变量及对应的方法存在重复编写
                于是，在代码中可以使用 extend 来表示两个类之间的关系，该关系只能用于表示继承(父子关系)
                    被继承的称为父类  继承的称为子类
                通过继承就可以获取父类中的相关代码

             继承关系的好处：
                1.提高了代码的复用性  父类代码可以直接被子类代码继承所使用
                2.提高了代码的维护性  如果功能的代码需要修改，修改一处即可
                3.让类与类之间产生了关系，是多态的前提 => 放到后面再介绍
                    代码之间产生依赖关系后，那么可以用 耦合性 来表示
                    耦合性太强的缺点：当上游代码发生改变时，会影响下游的 所以在开发过程中并不是所有的代码都要有很强的耦合性

             Java中继承的特点：
                1.一个类只能有一个父类，不可以有多个父类。为什么？
                        钻石问题（若父类中有一个同名方法，那么该继承谁的？）
                2.Java支持多层继承(继承体系)


             Java中方法的重写:
                1.方法是通过继承或实现其他类或接口得到的
                2.对得到的方法逻辑进行重写
                3.对于方法的重写要求 参数列表 方法名 返回值都是一样的

                重写和重载的区别：
                    1.重写是对继承后的方法进行重新定义，重载是对当前类中的方法进行拓展
                    2.重写需要使用 @Override 而 重载 不需要

           TODO JAVA中继承的注意事项：
                1.子类只能继承父类所有非私有的成员(成员方法和成员变量)
                    私有表示使用private修饰的
                2.子类不能继承父类的构造方法，但是可以通过super(后面讲)关键字去访问父类构造方法。
                3.不要为了部分功能而去继承
                    如果两个类在逻辑上能形成 is a 关系， 一个类是另外一个类的XXX 就可以使用

         */

        Cat cat = new Cat("咪咪");
        cat.run();
        System.out.println(cat.name);
//        cat.run("招财");
        cat.procreate();
//        System.out.println(cat.clazz);
        cat.weight = "3斤";

        cat.show();
    }
}

class Animal {
    int weight;

    public void run() {
        System.out.println("动物能够游泳或行走..");
    }
}

class mammal extends Animal {
    private String clazz = "哺乳动物类";


    public void procreate() {
        System.out.println("哺乳动物都可以胎生...");
    }
}


/*
    使用Cat子类来继承父类Animal
 */
class Cat extends mammal {
    String weight;
//    String clazz = "猫类";

    String name;
//    public void run(){
//        System.out.println("动物能够行走..");
//    }

    public Cat(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(name + "可以行走，爬树");
    }
    public void show(){
//        double weight = 3.2;
        System.out.println("猫咪叫:"+name+" 现在"+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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

4.继承中的构造方法

public class SuperOperator {
    public static void main(String[] args) {
        /*
            TODO 继承中的构造方法：
                1.对于子类对象在构建时，必须先创建其父类对象
                2.对于子类对象在调用构造方法时，默认需要先调用父类的无参构造
                3.在子类中使用super()调用父类的构造方法，必须要放在子类构造方法的第一行 ？
                    由于必须要先构建父类对象，所以根据代码执行顺序，需要先将父类的构造方法执行完成

            TODO 使用 super 关键字
                 super关键字用于表示父类，可以通过 super()调用父类的构造方法 或者使用 super.调用成员方法或变量

         */
        Son son = new Son("李杨",17);
        son.show();

        System.out.println("===================");
        Zi z = new Zi();
        z.show();

    }
}
/*
    对于一个代码文件中，只能存在有一个 public 修饰的class类
 */

class GrandFather {
    String name;
    int age;

    public GrandFather() {
        System.out.println("爷爷出现了...");
    }

    public final void show() {
        System.out.println("我叫" + name + " 今年：" + age);
    }
}

//final class Father extends GrandFather {
class Father extends GrandFather {
    public Father(String name, int age) {
        super.name = name;
        this.age = age;
        System.out.println("父亲出现了...");
    }
}

class Son extends Father {
    public Son(String name, int age) {
        super(name,age);
        System.out.println("儿子出现了...");
    }

//    @Override
//    public void show() {
//        System.out.println("这是儿子中重新定义的show方法");
//    }
}
class Fu{
    public int num = 10;
    public Fu(){
        System.out.println("fu");
    }
}
class Zi extends Fu{
    public int num = 20;
    public Zi(){
        System.out.println("zi");
    }
    public void show(){
        int num = 30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

5. final关键字

import java.util.Arrays;

public class Demo_Final {
    final static double PI = 3.145926;
    final static int[] INT_NUM = {3, 4, 6, 5};

    public static void main(String[] args) {
        /*
            TODO final
                ① 使用该关键字修饰class,后续不能被其他的类所继承  表示为最终类
                ② 使用该关键字修饰方法，后续不能被其他的子类所重写
                ③ 使用该关键字修饰变量，表示一个常量 定义后不可改变其中的数据 必须要进行初始化
                    常量的命名：所有单词字母大写，单词间使用 下划线 连接
         */
        System.out.println(PI);
//        PI = 3.1459267;
        INT_NUM[0] = 4;
//        INT_NUM = new int[5];  // 对于引用类型赋值不能修改其内存地址，但是可以修改其地址上对象的数据
        System.out.println(Arrays.toString(INT_NUM));

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

6.多态

public class MoreFormat {
    public static void main(String[] args) {
        /*
           TODO 多态
               前提条件，当多个类或者接口之间存在有继承或实现关系时，此时对于每个类都可以有其他的表示方式
                 举例：
                    张三 <= 张三人
                    张三他爸爸的儿子 <= 张三人
                    张三他爷爷的孙子 <= 张三人
                 对于一个人 可以有多种表示形式
               什么需要有多态？？
                    ① 对于继承关系来说，父类所有的变量及方法 其子类可以被继承
                    ② 当父类在方法中被调用时，那么其子类也应该满足其要求
                    ③ 为了增加方法的灵活性，可以将子类的对象传给父类变量进行使用
               多态定义: 父类引用指向子类对象
              注意：
                 ① 对于子类中独有的方法，当有多态时，不能通过父类引用调用子类对象的独有方法
                 ② 在强制类型转换时，需要存在有继承关系，才能相互转换
                 ③ 强制类型转换，不能违反多态的体系  父类引用指向子类对象



         */
        Sn son1 = new Sn("李白", 18);
        Fa son2 = new Sn("李白", 18);   // 多态
        GrandFa son3 = new Sn("李白", 18); // 多态

        GrandFa grandFa = new GrandFa();
        useInfo(grandFa); //
        useInfo(son1);
//        son2.pl

        //playGame()为son类中的独有方法，若是多态则无法引用，所有要进行强制类型转换
        Sn changeType2Son = (Sn) son3;
        changeType2Son.playGame();

//        String son31 = (String) son3;

//        Sn sn1 = new GrandFa();  // 出错

        // 错误
//        Sn fa = (Sn) grandFa; // grandFa变量中实际上保存的是 GrandFa 对象地址  进行强制类型转换
//        fa.playGame();

        /*
            TODO 多态中成员访问特点
                成员方法/成员变量:
                    编译看左边，运行看右边
                静态方法:
                    编译看左边，运行看左边

         */
        Sn sn1 = new Sn("彭飞", 18);
        System.out.println(sn1.name);

        GrandFa grandFa1 = new Sn("彭飞", 18);
        System.out.println(grandFa1.name);
        System.out.println(grandFa1.age);
//        System.out.println(grandFa1.skill);

        //默认调用子类中的show()方法
        grandFa1.show();
        //编译看左边，运行看左边
        grandFa1.run(); //  爷爷走路步履蹒跚...

    }

    public static void useInfo(GrandFa grandFa) {
        System.out.println("获取到了一个对象，其姓名为:" + grandFa.name + "年龄为:" + grandFa.age);

    }
//    public static void useInfo(Sn grandFa){
//        System.out.println("获取到了一个对象，其姓名为:"+grandFa.name+"年龄为:"+grandFa.age);
//    }

}

/*
    TODO 在相同的包下，类只能被定义一次，除了内部类形式
 */
class GrandFa {
    String name;
    int age;

    public GrandFa() {
        this.name = "爷爷";
        this.age = 60;
        System.out.println("爷爷出现了...");
    }

    public void show() {
        System.out.println("爷爷:" + "我叫" + name + " 今年：" + age);
    }

    //static：静态方法
    public static void run() {
        System.out.println("爷爷走路步履蹒跚...");
    }

}

//final class Father extends GrandFather {
class Fa extends GrandFa {
    public Fa(String name, int age) {
//        super.name = name;
        this.name = name;
        this.age = age;
        System.out.println("父亲出现了...");
    }
}

class Sn extends Fa {
    String name;
    String skill;

    public Sn(String name, int age) {
        super(name, age);
        this.name = name;
        this.age = age;
        System.out.println("儿子出现了...");
    }

    public void show() {
        System.out.println("孙子:我叫" + name + " 今年：" + age);
    }

    public void playGame() {
        System.out.println("孙子年轻，游戏玩的溜溜的...");
    }

    public static void run() {
        System.out.println("孙子走路蹦蹦跳跳");
    }
}
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

7.抽象类

public class AbstractClazz {
    
    public static void main(String[] args) {
        /*
            TODO 抽象类：
                在Java中表示抽象概念的类，可以定义为一个抽象类
                抽象类定义：
                    abstract 用于修饰抽象类
                    对于抽象类，不能进行实例化
                    抽象类可以定义非抽象方法
                抽象方法：
                    在定义方法时，没有给定具体的方法体，并且需要使用abstract修饰
                子类继承抽象类：
                    ① 如果子类不是抽象类并且当抽象类中存在有抽象方法，那么需要通过重写实现其抽象方法的逻辑
                    ② 子类可以继承到抽象类中的非抽象方法


               为什么需要有抽象方法：
                    在定义一个抽象类时，需要定义一个抽象方法，用于标记当前抽象类是存在有该行为的
                        主要的作用是为了规范代码 对于方法的参数以及返回值类型都已经固定了

               抽象类的使用场景：
                    1.当开发代码时，对于具体的功能不知道如何进行运行或定义时，
                            可以先给定一个抽象类，再调用其中的抽象方法 如果当其他开发人员 再开发相关的功能时，就可以
                                重写其对应的代码，实现功能


         */
        
        //补：
        /*
            一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
                可以，对于某一些类中存在有共有的方法，同时逻辑也相同，但是没有一个具体的类，可以将该方法
                    去表示出来，所以需要有一个抽象的概念，来表示，所以需要使用抽象类
         */

        /*
            abstract不能和哪些关键字共存
                private	冲突  => 私有  => 如果私有那么子类无法继承，也无法对其抽象方法进行重写 无意义
                final	冲突	 => 最终  => final 的类不能被继承，对于抽象类无法构造本身的实例对象，无意义
                static	无意义 => 属于类的 => 可以写但没有意义
         */
        
        
        Animal animal = new Animal(); // 对于Animal类来说，表示的应该是一个概念性
        animal.run();  // run方法，对于不同的子类，会对其方法进行重写

//        new AbstractAnimal().run();  //抽象类不能实例化
        DogAb dogAb = new DogAb();
        dogAb.run();
        dogAb.eat();

        /*
            TODO 使用抽象类
                可以通过 子实现类（继承抽象类的类）来调用重写/继承的方法
         */
        useAbstractAnimal(new DogAb());

//        new AbstractA();
        C c = new C();

    }

    public static void useAbstractAnimal(AbstractAnimal animal) {
        animal.run();
    }
}

abstract class AbstractAnimal {
    public abstract void run();  // 定义一个抽象方法

    public void eat() {
        System.out.println("动物需要觅食..");
    }
}

class DogAb extends AbstractAnimal {
    @Override
    public void run() {
        System.out.println("狗可以四肢行走...");
    }

//    public abstract void sleep();  // 有抽象方法的类一定是抽象类
}


/*
    TODO 抽象类的继承关系
 */

abstract class AbstractA{
    /*
        TODO 抽象类构造方法：
            1.对于抽象方法不能直接使用new 进行调用，但是可以通过创建子类对象的方式来进行调用
     */
    public AbstractA(){
        System.out.println("这是抽象类中的构造方法");
    }

    public abstract void function();
}

abstract class AbstractB extends AbstractA{
    /*
        对于抽象类继承抽象类，可以选择重写其方法，也可以不重写其方法
     */

    @Override
    public void function() {
        System.out.println("这是B抽象类中重写的方法");
    }
}

class C extends AbstractA{

    @Override
    public void function() {
        System.out.println("这是C具体类中重写的方法");
    }
}

class D extends AbstractB{
    /*
        TODO 对于B中继承A的抽象方法已经被重写了，D再继承时，就可以不需要再重写
     */
}


 
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129