Java面向对象拓展

发表于 | 分类于 ， | | 本文总阅读数 次
| 字数统计: 1.7k | 阅读时长 ≈ 7
Java面向对象拓展

2

Java面向对象拓展

  Java面向对象还有最最重要的部分知识，接口的问题，C++中允许多继承，而Java中不提供多继承，而是提供了接口的概念，在这里给大家做简单的介绍。

Java抽象方法

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
package demo01;

//如果父类中的方法不确定如何进行方法体的实现，则该方法是抽象方法，该类是抽象类。如动物类，无法确定他们吃什么东西，只有具体到某一个动物才可以确定，因此动物类就是一个抽象类。
//抽象类在public和class之间加上abstract关键字，抽象方法在权限修饰符和返回值之间加上abstract关键字。而且抽象方法不能写实现，直接在参数列表后面加分号即可。
//抽象类中不一定包含抽象方法，但是有抽象方法的一定是抽象类。
public abstract class Animal {
    String name;

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

    public abstract void eat();

    public abstract void speak();
}

package demo01;

//抽象类必须用一个子类继承抽象类，并且重写父类中所有的抽象方法才可以创建子类对象进行使用。如果没有重写父类的所有抽象方法，那么子类也是一个抽象类。
public class Cat extends Animal{
    public Cat(String name) {
        super(name);
    }

    //在重写父类的抽象方法中，可以在方法的上面一行加上@Override表示重写。
    //注意重写是在继承关系中，方法的名称一样，参数列表也一样，和函数的重载是不同的。
    //重写时子类方法的返回值范围必须小于等于父类方法的返回值范围，子类方法的访问权限必须大于等于父类方法的权限。
    @Override
    public void eat() {
        System.out.println("我是" + name + "，我喜欢吃鱼");
    }

    @Override
    public void speak() {
        System.out.println("我是" + name + "，我会喵喵喵");
    }
}

package demo01;

public class Dog extends Animal{
    public Dog(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println("我是" + name + "，我喜欢吃骨头");
    }

    @Override
    public void speak() {
        System.out.println("我是" + name + "，我会汪汪汪");
    }
}

package demo01;

public class Oop4 {
    public static void main(String[] args) {
        Cat cat = new Cat("小猫");
        Dog dog = new Dog("小狗");
        cat.eat();
        cat.speak();
        dog.eat();
        dog.speak();
    }
}

1

Java接口

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
package demo01;

//接口是一种公共的规范标准，接口中最重要的内容就是抽象方法。
//接口中可以包含常量，抽象方法，默认方法(Java8)，静态方法(Java8)，私有方法(Java9)
//接口的定义是public + interface + 接口名称
//接口中不允许出现静态代码块和构造方法。
// 类和接口的关系：类与类之间是单继承的，类与接口之间是多实现的，接口与接口之间是多继承的。
public interface A {
    //接口中可以定义成员变量，也是属于接口，必须使用public static final修饰，也可以省略，但是最好不要省略。
    //接口常量必须在定义时赋值，否则会报错，而且名称最好用完全大写的字母，并且用下划线分隔。
    public static final String NAME = "A";

    //接口中的抽象方法和抽象类中的抽象方法相同。
    public abstract void aMethod();

    //从Java8开始，接口中允许定义默认方法，可以通过接口实现类对象进行调用，也可以在接口实现类中进行重写。
    public default void defaultMethod() {
        System.out.println("我是接口A的默认方法");
    }

    //从Java8开始，接口中允许定义静态方法，不能通过接口实现类进行调用，和类中的静态方法不同，只能通过接口名.静态方法名进行调用。
    public static void staticMethod() {
        System.out.println("我是接口A的静态方法");
    }

    //从Java9开始，接口中允许定义私有方法，用于解决代码冗余问题，但是又不能暴露给实现类，因此需要私有化。包括普通私有方法和静态私有方法。
    private void privateMethod() {
        System.out.println("我是接口A的私有方法");
    }
}

package demo01;

public interface B {
    public static final String NAME = "B";

    public abstract void bMethod();

    public default void defaultMethod() {
        System.out.println("我是接口B的默认方法");
    }

    public static void staticMethod() {
        System.out.println("我是接口B的静态方法");
    }

    private void privateMethod() {
        System.out.println("我是接口B的私有方法");
    }
}

package demo01;

//定义类实现多个接口时，格式是public class 类名 implements 多个接口名，并用逗号分隔。
public class C implements A, B{

    //接口中的默认方法重复，必须进行重写，如果抽象方法重复，只需要覆盖重写一次即可。
    //如果实现类没有覆盖重写所有抽象方法，那么该类就是一个抽象类。
    //如果父类的方法和接口中的默认方法冲突，则优先使用父类中的方法。
    @Override
    public void defaultMethod() {
        System.out.println("我是C重写接口A和B的共同默认方法");
    }

    @Override
    public void aMethod() {
        System.out.println("我是C重写接口A的特有方法");
    }

    @Override
    public void bMethod() {
        System.out.println("我是C重写接口B的特有方法");
    }
}

package demo01;

public class Oop4 {
    public static void main(String[] args) {
        C c = new C();
        c.aMethod();
        c.bMethod();
        c.defaultMethod();
    }
}

1

Java中final关键字

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
package demo01;

//final修饰类名：代表当前类没有子类，无法被继承，而且该类的方法不能写成抽象类。
public final class FinalClassA {
    public void methodA() {
        System.out.println("我是ClassA中的methodA方法");
    }
}

package demo01;

public class ClassB {
    //final修饰方法名：代表该方法不能被子类覆盖重写，因此也不能写成抽象方法。
    public final void finalMethodB() {
        System.out.println("我是ClassB中的finalMethodA方法");
    }

    public void methodB() {
        System.out.println("我是ClassB中的methodB方法");
    }
}

package demo01;

public class ClassC extends ClassB{
    @Override
    public void methodB() {
        System.out.println("我是ClassC中重写的methodB方法");
    }
}

package demo01;

public class Oop4 {
    //final修饰成员变量，代表成员变量不可变，要么在定义时赋值要么在构造方法中赋值。
    public static final double PI = 3.14;
    public static void main(String[] args) {
        //final修饰局部变量，代表局部变量不可变
        final int R = 10;
        FinalClassA finalClassA = new FinalClassA();
        ClassB classB = new ClassB();
        ClassC classC = new ClassC();
        finalClassA.methodA();
        classB.finalMethodB();
        classB.methodB();
        classC.finalMethodB();
        classC.methodB();
    }
}

1

Java小结

  今天的内容是Java面向对象的拓展部分，也是Java中最最重要的部分，是和C++最核心的区别之一，小伙伴在今后的工作中肯定会和接口有很多交集，因此需要深刻理解。

-------------本文结束感谢您的阅读-------------
0%