Java_009_面向对象编程一

封装

  • 在⾯面向对象程式设计⽅方法中, 封装(英语:Encapsulation)是指⼀一种将类实现细节部分包装, 隐藏起 来的方法.
  • 封装⽅式: 类.
  • 对类的内部状态的访问进行控制, 只提供该提供的信息
  • 把代码分成两个部分: 接口 和 实现!
  • 接⼝因为涉及和外部的交互, 对⽤户暴露, 应该保持稳定. 例如: API和库
  • 内部实现不需要暴露给外部用户. 在接⼝功能不被影响的前提下, 可以随意修改和重构
  • 良好的封装是解耦的基础!
  • 代码实例例

访问修饰符

  • public
  • protected
  • default
  • private
1
2
3
4
5
访问权限   类   包  子类  其他包
  　　　　  public     ∨   ∨    ∨     ∨          （对任何人都是可用的）
   　　　　 protected    ∨   ∨   ∨     ×　　　 （继承的类可以访问以及和private一样的权限）
   　　　　 default    ∨   ∨   ×     ×　　　 （包访问权限，即在整个包内均可被访问）
   　　　　 private    ∨   ×   ×     ×　　　 （除类型创建者和类型的内部方法之外的任何人都不能访问的元素）

继承

get 和 set

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
class Student {

    private String name; // 姓名
    private int age; // 年龄
    private boolean male; // 是不是爷们儿

    public void setMale(boolean b) {
        male = b;
    }

    public boolean isMale() {
        return male;
    }

    public void setName(String str) {
        name = str;
    }

    public String getName() {
        return name;
    }

    public void setAge(int num) {
        age = num;
    }

    public int getAge() {
        return age;
    }
}

构造方法的重载

注意事项：

  1. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
  2. 构造方法不要写返回值类型，连void都不写
  3. 构造方法不能return一个具体的返回值
  4. 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。
    public Student() {}
  5. 一旦编写了至少一个构造方法，那么编译器将不再赠送。
  6. 构造方法也是可以进行重载的。

重载：方法名称相同，参数列表不同。

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
/*
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
格式：
public 类名称(参数类型 参数名称) {
    方法体
}
 */
public class Student {

    // 成员变量
    private String name;
    private int age;

    // 无参数的构造方法
    public Student() {
        System.out.println("无参构造方法执行啦！");
    }

    // 全参数的构造方法
    public Student(String name, int age) {
        System.out.println("全参构造方法执行啦！");
        this.name = name;
        this.age = age;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

}

final

final关键字代表最终、不可改变的。
常见四种用法：

  1. 可以用来修饰一个类
  2. 可以用来修饰一个方法
  3. 还可以用来修饰一个局部变量
  4. 还可以用来修饰一个成员变量
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
int num1 = 10;
System.out.println(num1); // 10
num1 = 20;
System.out.println(num1); // 20

// 一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
// “一次赋值，终生不变”
final int num2 = 200;
System.out.println(num2); // 200

// num2 = 250; // 错误写法！不能改变！
// num2 = 200; // 错误写法！

// 正确写法！只要保证有唯一一次赋值即可
final int num3;
num3 = 30;

// 对于基本类型来说，不可变说的是变量当中的数据不可改变
// 对于引用类型来说，不可变说的是变量当中的地址值不可改变
Student stu1 = new Student("赵丽颖");
System.out.println(stu1);
System.out.println(stu1.getName()); // 赵丽颖
stu1 = new Student("霍建华");
System.out.println(stu1);
System.out.println(stu1.getName()); // 霍建华
System.out.println("===============");

final Student stu2 = new Student("高圆圆");
// 错误写法！final的引用类型变量，其中的地址不可改变
//        stu2 = new Student("赵又廷");
System.out.println(stu2.getName()); // 高圆圆
stu2.setName("高圆圆圆圆圆圆");
System.out.println(stu2.getName()); // 高圆圆圆圆圆圆

JavaBean

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
/*
一个标准的类通常要拥有下面四个组成部分：
1. 所有的成员变量都要使用private关键字修饰
2. 为每一个成员变量编写一对儿Getter/Setter方法
3. 编写一个无参数的构造方法
4. 编写一个全参数的构造方法
这样标准的类也叫做Java Bean
 */
class Student {

    private String name; // 姓名
    private int age; // 年龄

    public Student() {
    }

    public Student(String name, int age) {
        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;
    }
}