面向对象、封装、就近原则及this关键字

面向:拿、找；
对象:能干活的东西；
面向对象编程:拿东西过来做对应的事；
即，分别找对应的“对象”完成对应的“事件”。因此学习内容包括：
①学习各种已存在的对象并使用；
②学习设计对象并使用。

面向对象的三大特征：

1. 封装；
2. 继承；
3. 多态。

一、 类和对象

类(设计图):是对象共同特征的描述
对象:是真实存在的具体东西
在Java中，必须先设计类，才能获得对象。

• 用来描述一类事物的类，专业叫做: Javabean类。
  在Javabean类中，是不写main方法的。
• 在以前，编写main方法的类，叫做测试类。
  我们可以在测试类中创建javabean类的对象并进行赋值调用。
  
  

二、封装

封装：对象代表什么，就得封装对应的数据，并提供数据对应的行为。

2.1 封装

Javabean类：

public class BoyFriend {

    //属性
    String name;
    int age;
    String gender;
    
    //行为
    public void sleep(){
        System.out.println("男朋友在睡觉");
    }
    public void eat(){
        System.out.println("男朋友在吃饭");
    }
}

测试类：

public class BoyFriendTest {
    public static void main(String[] args) {
        BoyFriend bf1 = new BoyFriend();
        bf1.name = "陆沉";
        bf1.age = 26;
        bf1.gender = "男";
        System.out.println(bf1.name);
        System.out.println(bf1.age);
        System.out.println(bf1.gender);
        bf1.eat();
        bf1.sleep();
        System.out.println("==================");
        BoyFriend bf2 = new BoyFriend();
        bf2.name = "萧逸";
        bf2.age = 23;
        bf2.gender = "男";
        System.out.println(bf2.name);
        System.out.println(bf2.age);
        System.out.println(bf2.gender);
        bf2.eat();
        bf2.sleep();
    }
}

但仅这样如果出现差错是很难检查出来的，每次输入都用if判断又很麻烦，因此可考虑使用private关键字进行权限修饰。

2.2 private关键字

• private关键字是一个权限修饰符
• 可以修饰成员(成员变量和成员方法)
• 被private修饰的成员只能在本类中才能访问
• 针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
• 提供“setXxx(参数)”方法，用于给成员变量赋值，方法用public修饰
• 提供“getXxx()”方法，用于获取成员变量的值，方法用public修饰

package onClass;

public class BoyFriend {
    //编写女朋友类，创建女朋友类的对象给女朋友的属性赋值并调用女朋友类中的方法。
    //自己思考，女朋友类中有哪些属性，有哪些行为?

    //属性
    private String name;
    private int age;
    private String gender;
    
    // set(给成员变量赋值)和get(对外提供成员变量的值)方法
    public void setName(String n){
        name = n;
    }
    public String getName(){
        return name;
    }
    public void setAge(int a){
        if (a>=18&&a<=28){
            age =a ;
        }else {
            System.out.println("非法参数");
        }
    }
    public int getAge(){
        return age;
    }
    public void setGender(String g){
        if (g=="男"){
            gender = g;
        }else {
            System.out.println("非法参数");
        }
    }
    public String getGender(){
        return gender;
    }


    //行为
    public void sleep(){
        System.out.println("男朋友在睡觉");
    }
    public void eat(){
        System.out.println("男朋友在吃饭");
    }
}

test:

package onClass;

public class BoyFriendTest {
    public static void main(String[] args) {
        BoyFriend bf1 = new BoyFriend();
        bf1.setName("陆沉");
        bf1.setAge(26);
        bf1.setGender("男");
        System.out.println(bf1.getName());
        System.out.println(bf1.getAge());
        System.out.println(bf1.getGender());
        bf1.eat();
        bf1.sleep();
        System.out.println("==================");
        BoyFriend bf2 = new BoyFriend();
        bf2.setName("萧逸");
        bf2.setAge(23);
        bf2.setGender("男");
        System.out.println(bf2.getName());
        System.out.println(bf2.getAge());
        System.out.println(bf2.getGender());
        bf2.eat();
        bf2.sleep();
    }
}

三、就近原则和this关键字

成员变量：定义在类里面的变量；
局部变量：定义在方法里的变量。

当成员变量和局部变量名字重合时，则会触发“就近原则”，即，离谁近，就用谁。
当不想触发就近原则时，可使用this关键字。“this.变量名”。
因此上面setname部分的代码就可进行优化（因为那里用了n，不符合定义变量“见名知意”的规定）：

...
private String name;
 public void setName(String name){
        this.name = name;
    }
...

name作为setName方法的局部变量，接收的是test类传过来的String，然后将其赋值给" this.name "，即类里面的成员变量name。
这样就既能“见名知意”，又不会被就近原则影响产生歧义了。

四、构造方法概述

构造方法也叫作构造器、构造函数。
作用:在创建对象的时候给成员变量进行赋值的。

总结：
1.构造方法的作用?
创造对象的时候，由虚拟机自动调用，给成员变量进行初始化的。

2.构造方法有几种，各自的作用是什么?
无参数构造方法:初始化的对象时，成员变量的数据均采用默认值。·有参数构造方法:在初始化对象的时候，同时可以为对象进行赋值。

3.构造方法有哪些注意事项?
任何类定义出来，默认就自带了无参数构造器，写不写都有。
一旦定义了有参数构造器，无参数构造器就没有了，此时就需要自己写无参数构造器了。
建议在任何时候都手动写上空参和带全部参数的构造方法

五、标准的javabean类

5.1 基本内容

1. 类名需要见名知意
2. 成员变量使用private修饰
3. 提供至少两个构造方法
   ① 无参构造方法
   ②带全部参数的构造方法
4. 成员方法
   提供每一个成员变量对应的setXxx()/getXxx()如果还有其他行为，也需要写上

5.2 快捷键和插件

使用alt+insert可以进行快捷插入空参、全部参数的构造、set和get方法。
插件“setting-plugin”找ptg，安装，这样在写好属性部分以后，就可以右键直接“Ptg to Javabean”。

5.3 标准Javabean的示例

包括：属性、空参的构造、全部参数的构造、属性分别的set和get方法。

public class User {
    //属性
    private String username;
    private String password;
    private String email;
    private String gender;
    private int age;

    //快捷键：alt+insert
    
    //空参
    public User() {
    }
    
    //全部参数的构造
    public User(String username, String password, String email, String gender, int age) {
        this.username = username;
        this.password = password;
        this.email = email;
        this.gender = gender;
        this.age = age;
    }
    
    //set和get
    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 String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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

六、内存情况

6.1 三种情况

6.1.1 一个对象的内存图

方法执行完以后就会出栈。

6.1.2 两个对象的内存图

6.1.3 两个引用指向同一个对象

6.2 基本数据类型和引用数据类型

基本数据类型：
整数类型
浮点数类型
布尔类型
字符类型

引用数据类型：
除了基本数据类型外的其他

6.3 this的内存原理

6.4 成员变量和局部变量

七、练习与补充

7.1 键盘录入的两套体系

两套体系不能混用，会出现错误。

package ArrayTest;

import java.util.Scanner;

public class KeyInput {
    public static void main(String[] args) {
        //nextInt(); 该方法只能接收Int类型的数据
        //nextDouble();接收小数
        //next();接收字符串
        //遇到空格，制表符，回车就停止接受。这些符号后面的数据就不会接受了

        //第二套体系:
        //nextLine();接收字符串

        //第一套体系：如果空格则直接把空格后的内容给下一个键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入第一个数：");
        int num1 = sc.nextInt();  //假设录入"123 456"
        System.out.println(num1); //这里输出"123"
        System.out.println("请录入第二个数：");
        int num2 = sc.nextInt(); //这里不会让你再录入了，而是直接把空格后赋给num2
        System.out.println(num2);//456
        //第一套体系的nextDouble()和next()都是这样

        //第二套体系：遇到回车才停止
        System.out.println("请录入第一个字符串：");
        String str1 = sc.nextLine();// 录入abc bcd
        System.out.println(str1);//打印abc bcd
        System.out.println("请录入第二个字符串：");
        String str2 = sc.nextLine();//需要继续录入
        System.out.println(str2);
    }
}