Java面向对象编程-2

面向对象目录
1 类与对象
2 封装 
  2.1 构造方法
  2.2 类的结构 
3 继承
  3.1 类的设计与扩展 
4 接口
  4.1 事件监听器
5 抽象类
6 泛型
7 枚举

2 封装

2.1 构造方法

1）访问权限修饰符

都可以修饰成员：作用于代码编译阶段，使用不当导致语法错误，编译不通过。 

访问权限修饰符及其规定的可访问区域见下表。

访问权限修饰符	可访问区域
public - 公共的	整个项目
private - 私有的	本类
protected - 受保护的	子类中&同包中
缺省/不写	同包中

2）属性封装

封装属性即私有化属性。

e.g. 封装User中的属性

public class User {

    private String userName;
    private int id;
    private String password;
    private String phoneNum;
    private int userAge;
    private double score;
    private boolean isOnline;
    private long time;

}

对属性的操作有两种：赋值与使用。

赋值：修改变量的值

使用：不修改变量的值

属性被封装后不可以在类外直接访问、操作，这就需要在类中定义方法用于在类外操作变量。set/get属性名，属性名首字母大写。

set：赋值

get： 获取属性值

e.g. 定义方法setUserName和getUserName，在类User外操作属性userName。

public class User {

    private String userName;

    public void setUserName(String userName) {
// this指代调用这个方法的对象，直接调用成员属性
// 使用变量时：就近原则
        this.userName = userName;
    }

    public String getUserName(){
        return userName;
    }

}



class Test{
    
    public static void main(String[] args) {
    
        User user1 = new User();
        user1.setUserName("0000");
        user1.getUserName();

    }

}

封装的优点： 

1、可以在属性赋值时校验参数的合法性；而未经封装的属性在创建对象时，其合法性则需要格外校验。e.g. 通过在setUserAge方法中加入判断语句校验参数userAge是否合法。（必须大于0）

    private void setUserAge(int userAge){
        if(userAge<=0){
            System.err.println("输入参数错误！");
        }else {
            this.userAge = userAge;
        }
    }

2、实现读写分离。可以实现只读、只写、读写。

3、格式更规范。避免直接使用“=”等运算符对属性进行操作。

4、数据更规范。可以在读取数据时完成数据转换。e.g.User中的getTime方法可以将long型时间数据（1667086476790）转换为规范的时间数据（Sun Oct 30 07:34:36 CST 2022）。

import java.util.Date;

public class User {

    private long time;

    public void setTime(long time){
        this.time = time;
    }

    public String get_Time() {
        return time;
    }

    public String getTime() {
        return new Date(time).toString();
    }
}

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

        User user1 = new User();
        long time = System.currentTimeMillis();
        user1.setTime(time);
        System.out.println(user1.get_Time());   
        System.out.println(user1.getTime());

    }
}

运行结果

1667086476790
Sun Oct 30 07:34:36 CST 2022

3）构造方法

格式：访问修饰符 类名(参数){ }

每个类都自带一个隐式的空参数构造方法。

显式的写了构造方法之后，就会覆盖隐式的，不管有无参数。

方法重载： 一个类中有多个同名的方法。要求：参数不一致。创建对象时，选择调用，只会执行一次。

每个对象至少调用两个构造方法，因为会调用父类的构造方法 ，每个类都会继承一个类Object。 

e.g.

public class User {

    private String userName;
    private int id;
    private String password;
    private String phoneNum;
    private int userAge;
    private double score;
    private boolean isOnline;
    private long time;

    public User(){}
    public User(String userName, int id, String password, String phoneNum, int
            userAge, double score, boolean isOnline,
                 long time) {
        this.userName = userName;
        this.id = id;
        this.password = password;
        this.phoneNum = phoneNum;
// this.userAge = userAge;
        this.setUserAge(userAge);
        this.score = score;
        this.isOnline = isOnline;
        this.time = time;
    }

    private void setUserAge(int userAge){
        if(userAge<=0){
            System.err.println("输入参数错误！");
        }else {
            this.userAge = userAge;
        }
    }

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

        User user1 = new User();
        User user2 = new User("",,"","",,...);

    }
}

4）单例模式与工厂模式

单例模式：这个类只会有唯一的一个对象。

例如，一个系统只有一个超级管理员账号 ，一个班级只有一个班主任 ，一个国家只有一个国王。

因此，不允许使用方创建对象，应当将构造方法设置为私有。同时在类中创建对象（使用static关键字，static修饰的变量只会存在一份）。

e.g. 

public class User {

    private String userName;

    // static 修饰的变量 只会存在一份
// 单例 这个类只会有唯一的一个对象
    static User king = new User();
    
    private User(){}
   
    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserName(){
        return userName;
    }

}

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

// 静态的 可以由类名直接调用
        User user1 = User.king;
        user1.setUserName("King A");
        User user2 = User.king;
        System.out.println(user2.getUserName());

    }
}

运行结果

King A

工厂模式：当有些对象创建过程太复杂，需要的参数等使用方没有办法轻易给到，因此需要在这个类中定义好创建对象的方法，直接返回一个成品对象。

同样，在工厂模式中，应当将构造方法设置为私有。

e.g. 

public class User {

    private String userName;
    private int id;
    private String password;
    private String phoneNum;
    private int userAge;
    private double score;
    private boolean isOnline;
    private long time;

    // 当有些对象创建过程太复杂，需要的参数等 第三方使用没有办法轻易给到 ，
// 工厂模型，这个类中定义好创建对象的方法，直接返回一个成品对象
    public static User createUser(){
// TODO
         String userName = ...;
         int id = ...;
         String password = ...;
         String phoneNum = ...;
         int userAge = ...;
         double score = ...;
         boolean isOnline = ...;
         long time = ...;

         return new User(userName, id, password, phoneNum, 
                    userAge, score, isOnline, time);
    }

    private User(String userName, int id, String password, String phoneNum, int
            userAge, double score, boolean isOnline,
                 long time) {
        this.userName = userName;
        this.id = id;
        this.password = password;
        this.phoneNum = phoneNum;
// this.userAge = userAge;
        this.setUserAge(userAge);
        this.score = score;
        this.isOnline = isOnline;
        this.time = time;
    }

    private void setUserAge(int userAge){
        if(userAge<=0){
            System.err.println("输入参数错误！");
        }else {
            this.userAge = userAge;
        }
    }

}

class Test{
    public static void main(String[] args) {
        
        User user1 = User.createUser();

    }
}