JavaSE 基础知识_java se

---

前言

本文将对Java的三大特性：封装、继承、多态进行简单的说明，涉及abstract、final、static、implements、extends……等关键字，主要对父类和子类的继承、方法的重载和重写进行详细的叙述。
Tips：小白一枚，分享一些学习心得，请大佬们指正！

（一）对象和类

1.类的声明

[访问控制符] [修饰符] class 类名 [extends 父类] [implements 接口]{}
1

extends关键字的意思是继承，使用该关键字可以让该类继承另外一个类（只能一个）
implement关键字的意思是实现接口，使用该关键字可以实现一个或多个接口

1.1访问控制符

1.2修饰符

2.变量的声明

[访问控制符] [修饰符] 变量类型 方法名称 变量名称
1

2.1访问控制符

2.2修饰符

一般用static和final共同定义一个常量，名称所有字母都大写，以便与变量区分。

private static final int MAX = 50;
1

3.方法的声明

[访问控制符] [修饰符] 方法返回值类型 方法名称 ([参数类型 参数列表]) [throws 异常]
1

3.1访问控制符

3.2修饰符

（二）三大特性

1.封装

封装就是把对象的属性和服务结合成一个独立相同的单位，并尽可能隐蔽对象的内部细节。
封装的两层含义：
（1）把对象的所有属性和方法都打包在一起，形成一个独立相同的单位（对象）。对象的私有属性只能由对象的行为来读和写。
（2）尽可能隐蔽对象的内部细节，通过外部接口与外界实现进行联系。
封装的优点：高内聚，低耦合，减少依赖。
代码示例：
（1）Person 类封装 name、gender、age 等属性，外部只能通过 get() 方法获取一个 Person 对象的 name 属性和 gender 属性，而无法获取 age 属性，但是 work() 方法可以使用age属性。
（2）其次，sex属性的类型是int型的，通过0和非0对性别进行判断，这也是隐藏内部细节的一种体现。

public class Person{
    private String name;
    private int sex;
    private int age = 18;

    public String getName() {
        return name;
    }

    public String getSex() {
        if (sex == 0){
            return "man";
        }else{
            return "woman";
        }
    }

    public void work(){
        if(age < 60){
            System.out.println(age + "岁还能继续干！");
        }else if(age >= 60){
            System.out.println(age + "岁该退休了");
        }
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.work();
    }

}
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

2.继承

继承可以简单的理解为一个对象直接使用另一个对象的属性和方法，前者称为子类（继承），后者称为父类（被继承）。在Java中，一个子类只能继承一个父类，但是一个父类却可以被多个父类继承。
子类继承父类需遵循以下原则：
（1）子类不能继承父类的private成员变量/方法，可以继承public和protected成员变量/方法；
（2）子类能继承同一包中有默认权限修饰符static的成员变量/方法；
（3）子类不能继承父类的构造方法，但可以通过super()进行调用。
代码示例：
父类：Animal动物类

public class Animal {
    public void eat(){
        System.out.println("动物要吃饭！");
    }
}
1
2
3
4
5

子类：Cat猫类，通过extends关键字进行继承，可以使用父类直接生成子类对象，生成的子类拥有父类的相关方法和属性。

public class Cat extends Animal{
    public static void main(String[] args) {
        Animal animal = new Cat();  //使用父类直接生成子类对象
        animal.eat();
    }
}
1
2
3
4
5
6

3.多态

多态可以分为静态多态性和动态多态性两种。
静态多态性：即编译时多态，主要指方法的重载。
动态多态性：即运行时多态，主要指方法的覆盖。

3.1方法的覆盖/重写

概念：方法的覆盖（重写）是指子类中的方法与父类中继承的方法有完全相同的返回值类型、方法名、参数个数以及参数类型，但两者方法体（内容）不同。
需注意的是：
（1）不能覆盖父类的final方法。
（2）不能覆盖父类的static方法，但可以进行隐藏。即在子类重写的方法前加上static。
（3）非抽象子类必须覆盖父类（abstract）中的抽象方法。

//父类
public class Animal {
    public void eat(){
        System.out.println("动物要吃饭！");
    }
}

//子类
public class Cat extends Animal{
    public void eat(){
        System.out.println("猫要吃鱼！");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

3.2方法的重载

方法的重载可以简单的理解为，在同一个类中，返回值类型、方法名相同，但是参数（个数或类型）不同的方法。
代码示例：
方法二对方法一进行重载

//构造方法一
public Person() { 
       System.out.println("我是无参的构造方法！");
   }
   
//构造方法二
public Person(String name, int sex, int age) { 
     this.name = name;
     this.sex = sex;
     this.age = age;
     System.out.println("我是有参的构造方法！");
 }
1
2
3
4
5
6
7
8
9
10
11
12

（三）接口

Java中一个子类只能继承一个父类，即单继承；但允许一个类实现多个接口，以达到多继承的效果。

1.1接口的声明

Tips：
（1）接口中的方法默认是abstract，不管有没有加上修饰符。
（2）接口若为public，那么该接口可被任意类实现，否则只有与接口在同一个包中的类实现。
代码示例：

[访问控制符] <interface> <接口名> {
	静态常量及方法声明
}
//示例
public interface Animal {
	//接口中的方法默认是abstract
	//只有方法声明，没有方法体
    public void eat();
    public void sleep();
}
1
2
3
4
5
6
7
8
9
10

1.2接口的实现

只需通过implements关键字即可实现接口，多个接口只需用逗号分隔。
Tips：必须实现接口中所有的方法，且实现接口的方法要保证其方法的返回值类型、方法名和方法的参数列表与接口中的完全一致。

public class Pig implements Animal{
    @Override
    public void eat() {
        System.out.println("猪吃玉米！");
    }

    @Override
    public void sleep() {
        System.out.println("猪要睡觉！");
    }
}
1
2
3
4
5
6
7
8
9
10
11

参考文献：
苑俊英、陈海山《Java程序设计及应用——增量式项目驱动一体化教程》 [ M ] 北京：电子工业出版社 2021.1