封装复习.md · 八月/java学习笔记

# Java面向对象语法

## 类与对象
### 类的提出
在编程语言当中，都有设计一些可以直接使用的数据类型（比如：基本数据类型），另外先人也会帮我们设计一些常用的数据类型。但是，够不够呢？不够，因为我们在实际开发中遇到的场景是千变万化的，是先人根本预料不到的，所以我们需要自己定义一些符合当前场景的类型供我们自己使用。

这样的想法早在C语言当中就提出来了，只不过C没有提出类的概念，而是提出了“结构体”的概念；当时的这个结构体就是一个可以存放多个数据变量的类型，只是里面没有函数。

到了面向对象的编程思维开始流行以后，我们就提出是否能够有一种更高级的类型，这个类型除了拥有各种数据以外，还能够包含行为方法，这就是“类”的概念；

### 为什么要提出类的概念？
这个是人类通过社会实践与分析各种场景得到的一个思维结果。

面向对象的思维方式到底是什么样子？

首先，分析问题域；在这个问题域当中寻找参与的“角色”，在这个过程当中我们往往会带入某个具体的角色对象来进行模拟过程的分析。

然后在这个过程中，找到这个问题域有哪些角色，每个角色有哪些数据（属性），每个角色能做什么（行为-方法）。

接着，我们开始编码，但是我们编码不能针对某个具体的对象来进行，因为在实际场景中，这种同类型的对象会很多且数据这些会变化。所以，我们需要先书写一个模版来表示这种角色（类出来了）。

而有了类以后，我们不能直接使用类，而是要通过类去产生各种同类型对象，让对象去进行操作。

### 类和对象的关系
类与对象 就是 模版与实例的关系。

设计类、使用对象。
设计类是为了确定一种 *“数据类型”*。在这种数据类型中去定义，该类型拥有哪些属性和行为。

用这个类去产生对象，而它产生的对象也就同样拥有了这些属性和行为。理论上，一个类能够产生无数个对象，那么每个对象都有自己的属性和行为吗？由于每个对象虽然属性的个数和名字一样，但是数据值不同，所以每个对象都需要单独分配空间存放属性。而方法，所有的同类型对象都是拥有同样的方法声明和实现，所以不需要在每个对象上单独存放，统一存放即可。

当对象产生以后，我们就可以操作这个对象，给它的属性取值赋值，调用它的方法实现它的功能行为。

### 如何从问题域中进行OO分析？

1、从问题域当中找“名词”

ATM 用户 用户卡号 密码 余额 现金
         
2、分析哪些名词是有现成的数据类型（语言自带的或先人预先写好的）能表示的；那么那些没有现成数据类型表示的，就是需要我们自己定义的；

3、接着我们要看这些名词与名词的关系了；A拥有B，就把B设计为A的属性；

4、然后再确定每个属性的修饰符；变量属性的访问修饰符几乎全是private，常量属性全是public static；

5、分析是否需要get/set方法；

6、从问题域当中找“动词”；

登陆、菜单选择、存钱、取钱、查询、修改密码、转账、退出;

7、分析这些动作是谁的行为？还要确定这些行为的参数、返回和访问修饰符

总结一下：
面向过程主要是分析完成一件事情步骤；
面向对象是分析参与这件事情的角色，然后定义类，确认每个类的属性和行为，以及类与类之间的关联关系。

### 类与类之间的关联关系
在很多时候，同一个场景使用不同的关联关系其实都有可能完成当前的工作。只是说越符合场景的，越能够让我们的程序随着场景的升级发生变动（变量量最小）。

has - a //属性
use - a //某个方法局部变量
is - a // 继承
like - a // 接口

### 这个章节的重点内容
1、类的定义语法 -- 属性/行为

2、通过类产生对象的语法 以及对象在内存中的存放形式；

内存划分：
   在程序中所有的数据和指令都是产生或存放在内存当中的。但是，内存里面还有进一步的区域划分，不同的内容是放在不同的区域中的。

栈区（stack）：局部变量是存放在栈区；

堆区：new 出来的对象是放在堆区的；当然由于对象身上是要存放属性的，这些属性当然也是在堆区；

数据段: 数据本身由划分为2个；
一个是字符串常量池：我们在代码中的所有书写的字符串常量对象都会放在这里。

另一个是静态区：类身上的static属性是放在这里的。

代码段（方法区）：方法代码块存放位置。

3、类与类的关联关系 -- has/use-a
   要从场景上去区分；

4、常用的特殊语法：this关键字
   当使用"this."代表的是当前对象的；

5、用完对象以后需要销毁 -- 垃圾回收机制（GC）
对于GC，你们需要知道的是：
5-1、GC是Java提供的一个内在机制，程序员是不能直接操控的；
5-2、GC复杂的回收算法中，你们目前只需要知道一条：没有引用指向的对象，在使用完以后就会被回收。
        
## 封装
封装的概念：不要把封装的概念想得太小。至少你们要能够梳理出如下几点：

1、封装不是一个概念而是“封”和“装”两个；且应该先装，再封；

2、封 是信息的隐藏，而不仅仅是数据的隐藏。包括：方法的定义对于调用者来说也是一种信息隐藏；类的定义对于使用者来说也是一种隐藏；

3、封 是有级别的，不是说只有private这种完全让外部看不到的才是封；所有的访问修饰符都是封装性的一部分，代表了不同的封装级别。

4、get/set方法的提出，也是一开始基于封装的思想，然后慢慢的成为开发人员的统一认识，形成为Java Bean的规范之一。

### 类里面能装什么？
属性、行为、构造、初始化块、内部类

1、构造方法
构造方法与普通方法的不同：

语法 --- 
构造方法的名字只能是类名(普通方法的名字可以根据需要任意取)；

构造方法没有返回类型的（抠字眼：没有返回类型，不是没有返回值）；

构造方法就算不写，编译器也会默认生成一个公共无参构造。但是一旦程序员定义了构造方法，那么编译器就不会提供默认构造了。

功能 --- 
构造方法的作用是“产生对象”；普通方法的作用是完成某个行为动作。
这里有一个细节--构造方法产生对象的步骤：
step1: 在堆当中划分空间；这个空间是真正存放对象的空间，所以它的大小依赖于对象的大小；而对象的大小又依赖于它所属类的定义，定义了多少属性，每个属性又是什么类型的占多大......

step2: 在这个对象空间上划分属性，哪部分存放a属性，哪部分存放b属性

step3: 对属性进行初始化，基本数据类型属性初始化为0；引用数据类型属性初始化为null；除非，程序员在属性的声明后面赋了指定初始值。

step4: 执行程序员在构造方法里面写的代码；

### 方法重载
概念：在一个类当中，拥有多个重名方法，那么它们的参数列表必须不同。参数列表的不同包括：参数个数、参数类型和参数顺序。

构造方法是允许重载的，也就是说一个类可以定义多个构造方法。

### this的第二种用法 -- this()
在本类的构造方法里面，调用本类的另一个构造方法，从而达到让构造方法的代码能够复用。

1、this()只能写在构造方法里面；

2、this()只能写在构造方法里面的第一句；

3、this()是一种简略说法，它是可以传参的。

## 类的高级概念

### static
凡是用static修饰的内容，都具有两个特性：
1、这个内容与对象无关，只和类有关；
2、这个内容会在加载期搞事情；

#### static修饰属性
static修饰属性具有全类共享一个值的特点；

static属性没有存在每个对象身上，而是存在内存的数据段的静态区里面，且只存放了一个。

static属性是在加载类的的时候，就被产生然后放在内存中了。

语法：
普通属性必须用对象.的方式访问；因为我们必须指明是哪个对象的这个属性。

static属性既可以用对象.的方式访问，也可以用类名.的方式访问；IDEA在联想的时候，如果是对象.是不会联想出静态属性的；但是如果我们一定要去写，它是不会报错的。这是IDEA的设计人员建议我们尽量用类去操作静态属性，因为它与对象无关。

设计上什么样的属性设计为静态的？什么样的设计为普通的？

我们只有真的找到在场景中某个属性是全类共享一个值的，才能做static属性的设计。目前，对于大家来说只有常量属性，你们能无脑设计为static的。

#### static不能修饰构造

原因：构造方法的作用是产生对象的，所以这个方法是和对象有关系的。但是凡是static修饰的又与对象无关，冲突了，所以static不能修饰构造。

#### static修饰行为
static修饰的方法的特点：
1、静态方法内部不能访问非静态的内容（包括非静态的属性 或 调用本类的非静态方法） --- 这是因为静态方法内部不能确定当前对象，而非静态内容都必须绑定到对象那个身上；

2、非静态方法内部是可以操作静态属性和调用静态方法的；

为什么会有这个语法特点呢？
这是因为在加载类的时候，JVM的加载顺序是先加载静态的，再加载非静态的。

设计上，什么样的方法设计为静态？什么方法设计为非静态的？
工具类的工具方法 设计为 static

#### static修饰初始化块
首先说说初始化块的语法：
```java
public class 类{ 
    //实例初始化块
    {
        书写指令语句
    }

}

public class 类{
    //静态初始化块
    static{
        书写指令语句
    }
}

```

通过探究，我们知道了新的new对象的步骤：
1、产生对象；
2、划分属性；
3、属性初始化；
4、执行实例初始化块
5、构造方法内部代码

实例初始化块的功能与构造方法重复，且还不能从外部接收参数，所以基本上没有使用的必要。

静态初始化块，是在加载类的时候被执行一次，且只执行一次。所以，在很多大型项目当中，static初始化块往往用于对资源的预加载动作，用得还比较多。

#### static修饰内部类
这个以后再说吧。。。。。。

## 作业：
1、在我的设计基础上，实现ATM；

```java
public class User {
    private String username;//用户名
    private String password;//密码
    private double account;//余额
//无参构造
    public User() {
    }
//带参构造
    public User(String username, String password, double account) {
        this.username = username;
        this.password = password;
        this.account = account;
    }
//get和set方法
    public String getUsername() {
        return username;
    }

public void setUsername(String username) {
        this.username = username;
    }

public String getPassword() {
        return password;
    }

public void setPassword(String password) {
        this.password = password;
    }

public double getAccount() {
        return account;
    }

public void setAccount(double account) {
        this.account = account;
    }
}
```

```java
public class ATMMachine {

private static User[] allUsers; //在ATM中预存的用户信息
    private User theUser;//代表当前登陆用户
    private int cash = 200000;//ATM机中当前现金量
    public static final int MAX_CASH = 400000;//ATM机中最大现金量
//随便给预存的用户信息赋值，便于测试用
    static{
        allUsers = new User[5];
        for(int i = 0; i < allUsers.length; i++){
            allUsers[i] = new User("J19" + i,"123456"+i,i*1000 + 200);
        }
    }

public ATMMachine(){
    }

//运行 --- 控制ATM的执行流程
    public void run(){
        boolean flag = this.login();
        if(flag){
            //这里循环直接使用true是因为退出功能那里写的是System.exit(0);//关闭虚拟机，一般来说还可以写个Boolean flag=true；while（flag）然后再退出功能那里改变flag值
                switch (item) {
                    case "1":
                        query();
                        break;
                    case "2":
                        storeMoney();
                        break;
                    case "3":
                        getMoney();
                        break;
                    case "4":
                        transMoney();
                        break;
                    case "5":
                        changPwd();
                        break;
                    case "6":
                        exit();
                        break;
                    default:
                        System.out.println("没有你输入的选项，请重新选择。");
                        break;
                }
            }

}else{
            System.out.println("三次登陆失败....");
        }
    }
//登录功能(还有一种方案可以不用返回Boolean类型，可以根据当前登录用户theUser是否为空判断是否登录成功)
    private boolean login(){
        Scanner scan = new Scanner(System.in);
        for(int i = 0; i < 3; i++){
            System.out.println("请输入用户名：");
            String inputname = scan.next();
            System.out.println("请输入密码：");
            String inputPwd = scan.next();
            for(User u : allUsers){
                if(u.getUsername().equals(inputname) && u.getPassword().equals(inputPwd)){
                    this.theUser = u;//把当前用户赋值为登陆成功用户
                    System.out.println("欢迎你，" + inputname);
                    return true;
                }
            }
            System.out.println("用户名密码有误，你还有" + (2 - i) + "次机会。");
        }
        return false;
    }
//选择菜单功能
    private String choiceMenu(){
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入你要执行的操作：");
        System.out.println("1、查询；2、存款；3、取款；\n4、转账；5、改密；6、退出");

return scan.next();
    }
    //查询功能
    private void query(){
        System.out.println("你当前的余额是:"  + this.theUser.getAccount() + "元。");
    }
//存钱功能(学会合理使用return手段减少if else嵌套)
    private void storeMoney(){
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入你要存款的金额：");
        int inputMoney = scan.nextInt();
        /*
            1、输入有效性验证; --- 你们还不会做
            2、业务有效性验证。--- 你们必须要有意识
            必须是正整数；必须是百元整数;与现金相加后不能超过MAX_CASH
         */
        if(inputMoney <= 0){
            System.out.println("本ATM只接收正数金额");
            return;
        }
        if(inputMoney % 100 != 0){
            System.out.println("本ATM只接收百元整钞");
            return;
        }
        if(inputMoney + this.cash > ATMMachine.MAX_CASH){
            System.out.println("本ATM容量不足，请换一台或减少存款金额");
            return;
        }
        theUser.setAccount(theUser.getAccount() + inputMoney);
        this.cash += inputMoney;
        System.out.println("存款操作成功，请查询余额确定");
    }

private void getMoney(){
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入你要取款的金额：");
        int inputMoney = scan.nextInt();

if(inputMoney <= 0){
            System.out.println("本ATM只接收正数金额");
            return;
        }
        if(inputMoney % 100 != 0){
            System.out.println("本ATM只提供百元整钞");
            return;
        }
        if(inputMoney > theUser.getAccount()){
            System.out.println("你的余额不足，请减少取款金额");
            return;
        }
        if(inputMoney > this.cash){
            System.out.println("本ATM现金不足，请减少金额或换一台");
            return;
        }

theUser.setAccount(theUser.getAccount() - inputMoney);
        this.cash -= inputMoney;
        System.out.println("取款操作成功，请查询余额确定");
    }

private void changPwd(){
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入你的原密码：");
        String oldPwd = scan.next();
        System.out.println("请输入你的新密码：");
        String newPwd = scan.next();
        System.out.println("请输入你的确认密码：");
        String confirmPwd = scan.next();

if(!oldPwd.equals(this.theUser.getPassword())){
            System.out.println("原密码输入错误，不能继续修改密码");
            return;
        }
        if(!newPwd.equals(confirmPwd)){
            System.out.println("两次新密码输入不一致，不能继续修改密码");
            return;
        }

this.theUser.setPassword(newPwd);
        System.out.println("密码修改成功，下次登陆生效。");
    }

private void transMoney(){
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入收款方账号：");
        String inputname = scan.next();

if(inputname.equals(theUser.getUsername())){
            System.out.println("不能自己给自己转账");
            return;
        }

User toUser = null;
        for(User u : allUsers){
            if(inputname.equals(u.getUsername())){
                toUser = u;
            }
        }
        if(toUser == null){
            System.out.println("你输入的账户不存在，无法转账");
            return;
        }

System.out.println("请输入你要转账的金额：");
        double inputMoney = scan.nextDouble();
        if(inputMoney <= 0){
            System.out.println("转账操作不允许小于0的金额");
            return;
        }

if(inputMoney > this.theUser.getAccount()){
            System.out.println("你的余额不足，本次转账失败");
            return;
        }

this.theUser.setAccount(this.theUser.getAccount() - inputMoney);
        toUser.setAccount(toUser.getAccount() + inputMoney);
        System.out.println("转账操作成功，请查询你的余额并通知对方查询");
    }

private void exit(){
        System.out.println("谢谢你的使用，期待下次为你服务。");
        System.exit(0);//关闭虚拟机
    }
```

2、请考虑设计一个类型替换掉int[]；因为，int[] 有一个很大的问题，就是容量大小一旦确定不能更改。我们希望设计一个类，可以装任意多个int元素，它自己能够自动的扩容或缩容。
具体要求：
2-1、首先它能够装很多的int；
2-2、当它容量不够的时候，自动扩大10个位置；
2-3、当我们从它当中减少元素的时候，如果空余位数大于10，那么缩小10个，但是如果只剩10个，就不会再缩小。
2-4、能够完成基本的放入元素，获取元素，删除元素，修改元素，获取元素个数的功能。

```java
public class SuperArray {
    //属性 --- 值数据
    private int[] array = new int[10];
    private int index;//1、下一个元素的下标；2、还表示当前有多少个元素

//行为
    public void add(int element){
        this.array[index] = element;
        index++;
        if(this.index == this.array.length){
            int[] newArray = new int[this.array.length + 10];
            /*
            	System.arraycopy数组拷贝
                5个参数：
                1、原数组;2、原数组的起始位置；3、目标数组；4、目标数组的起始位置；5、多少个
             */
            System.arraycopy(this.array,0,newArray,0,this.array.length);
            this.array = newArray;
        }
    }

public int get(int index){
        if(index >= 0 && index < this.index) {
            return this.array[index];
        }else{
            throw new ArrayIndexOutOfBoundsException();//抛异常
        }
    }

public void set(int element,int index){
        if(index >= 0 && index < this.index) {
            this.array[index] = element;
        }else{
            throw new ArrayIndexOutOfBoundsException();
        }
    }

public void remove(int index){
        if(index >= 0 && index < this.index) {
            System.arraycopy(this.array,index + 1,this.array,index,this.index - index - 1);
            this.index--;

if(this.array.length > 10 &&
                this.array.length - this.index > 10){
                int[] newArray = new int[this.array.length - 10];
                System.arraycopy(this.array,0,newArray,0,newArray.length);
                this.array = newArray;
            }

}else{
            throw new ArrayIndexOutOfBoundsException();
        }
    }

public int size(){
        return this.index;
    }
}
```

八月/java学习笔记

简介

发行版

贡献者

近期动态