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

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

面向对象的三大特征:

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

一、 类和对象

(设计图):是对象共同特征的描述
对象:是真实存在的具体东西
在Java中,必须先设计类,才能获得对象。
面向对象、封装、就近原则及this关键字_第1张图片

  • 用来描述一类事物的类,专业叫做: Javabean类
    在Javabean类中,是不写main方法的。
  • 在以前,编写main方法的类,叫做测试类
    我们可以在测试类中创建javabean类的对象并进行赋值调用。
    面向对象、封装、就近原则及this关键字_第2张图片
    面向对象、封装、就近原则及this关键字_第3张图片

二、封装

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

2.1 封装

面向对象、封装、就近原则及this关键字_第4张图片

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关键字_第5张图片
当成员变量和局部变量名字重合时,则会触发“就近原则”,即,离谁近,就用谁。
当不想触发就近原则时,可使用this关键字。“this.变量名”。
因此上面setname部分的代码就可进行优化(因为那里用了n,不符合定义变量“见名知意”的规定):

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

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

四、构造方法概述

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

面向对象、封装、就近原则及this关键字_第6张图片
面向对象、封装、就近原则及this关键字_第7张图片
总结
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 一个对象的内存图

面向对象、封装、就近原则及this关键字_第8张图片
方法执行完以后就会出栈。

6.1.2 两个对象的内存图

面向对象、封装、就近原则及this关键字_第9张图片

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

面向对象、封装、就近原则及this关键字_第10张图片

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

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

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

面向对象、封装、就近原则及this关键字_第11张图片

6.3 this的内存原理

面向对象、封装、就近原则及this关键字_第12张图片

6.4 成员变量和局部变量

面向对象、封装、就近原则及this关键字_第13张图片

七、练习与补充

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);
    }
}

你可能感兴趣的:(JAVA学习记录,java,jvm)