• 黑马Java笔记第七讲—面向对象

    🎨 个人介绍

    👉大家好，我是：知识的搬运工旺仔

    👉认真分享技术，记录学习过程的点滴，如果我的分享能为你带来帮助，请支持我奥🍻

    👉你的支持，是我每天更新的动力。

    👉赞点：👍 留言：✍ 收藏：⭐

    👉个人格言：想法一步一步的落实，才是你我前进最佳选择。

    黑马Java笔记第七讲—面向对象

    1. 类和对象

    1.1 类和对象的理解

    1 ）客观存在的事物皆为对象，所以我们常常说万物皆对象

    2 ）类

    1. 类的理解

      • 类是对现实生活中一类具有共同属性和行为的事物的抽象
      • 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
      • 简单理解：类就是对现实事物的一种描述

    2. 类的组成

      • 属性：指事物的特征，例如：手机事物（品牌，价格、尺寸）
      • 行为：指事物能执行的操作，例如：手机事物(打电话、发短信)

    3. 类和对象的关系

      • 类：类是对现实生活中一类具有共同属性和行为的事物的抽象
      • 对象：是能够看得到摸得着的真实存在的实体

    1.2 类的定义

    1 ）类的组成是由属性和行为两部分组成的

    • 属性：在类中通过成员变量来体现（类中方法外的变量）
    • 行为：在类中通过成员方法来体现

    2 ）类定义的步骤

    1. 定义类
    2. 编写类的成员变量
    3. 编写类的成员方法
    public class 类名 {
    //成员变量
    数据类型  变量1;
    数据类型  变量2;
    
    //成员方法
    方法1;
    方法2;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    1. 实例代码
    public class Phone {
    //成员变量
    String brand;
    int price;
    
    //成员方法
    public void call() {
        System.out.println("打电话");
    }
    
    public void sendMessage() {
        System.out.println("发短信");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    1.3 对象的使用

    1 ）创建对象的格式：

    • 类名 对象名 = new 类名();

    2 ）调用对象的格式：

    • 对象名.成员变量
    • 对象名.成员方法();

    3 ）实例代码

    public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();
        
        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);
        
        //使用成员方法
        p.call();
        p.sendMessage();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    1.4 学生对象-练习

    需求：首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量方法的使用

    分析：

    1. 成员变量：姓名，年龄…
    2. 成员方法：学习，做作业…

    实例代码

    class student {
    //成员变量
    String name;
    int age;
    
    //成员方法
    public void study() {
        System.out.rpintln("好好学习，天天向上");
    }
    
    public void doHomeWork() {
        System.out.println("键盘敲烂，月薪过万");
    }
}
​
public class StudentDemo() {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        
        //使用对象
        System.out.println(s.name + "," + s.age);
        
        s.name = "林青霞";
        s.age = 30;
        
        System.out.println(s.name + "," + s.age);
        
        s.study();
        s.doHomework();
    }
}

    • 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

    2. 对象内存图的总结

    1. 多个对象在推内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象公用的一份
    2. 当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的），只有任何一个对象修改了内存中的数据，随后，无论使用那个对象进行数据获取，都是修改后的数据

    3. 成员变量和局部变量

    3.1 成员变量和局部变量的区别

    1. 类中位置不同：成员变量（类中方法外）局部变量 （方法内部或者定义在方法上的变量）
    2. 内存中位置不同：成员变量（推内存），局部变量（栈内存）
    3. 生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，随着方法的调用完毕而消失）
    4. 初始化值不同：成员变量（有默认初始化值）局部变量(没有默认初始化值)，必须先定义，赋值才能使用

    4. 封装

    4.1 private 关键字

    1 ）private 是一个修饰符，可以用来修饰成员（成员变量，成员方法）

    2 ）被private 修饰的成员，只能在本类进行访问，针对private修饰的成员变量，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

    1. 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
    2. 提供“set变量名()"方法，用于获取成员变量的值，方法用public修饰

    3 ）实例代码

    class Student {
    //成员变量
    String name;
    private int age;
    
    //提供get 和 set 方法
    public void setAge( int a) {
        if(a<0 || a> 120) {
            System.out.println("你给的年龄有误");
        }else {
            age = a;
        }
    }
    
    public int getAge() {
        return age;
    }
    
    //成员方法
    public void show( ) {
        System.out.println(name + "," + age);
    }
}
​
//学生测试类
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        
        //给成员变量赋值
        s.name = "林青霞";
        s.setAge(30);
        
        //调用show()方法
        s.show();
    }
}

    • 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

    4.2 private的使用

    需求：定义标准的学生类，要求name和age使用private修饰，并提供set和get方法，以及便于显示数据的show方法，测试类中创建对象并使用，最终控制台输出 :林青霞 ，30

    实例代码：

    Class Student () {
    //成员变量
    private String name;
    private inr age;
    
    //get ,set方法
    public void setName (String n) {
        name = n;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int a) {
        age = a;
    }
    
    public void show() {
        System.out.prinln(name + "," + age);
    }
}
​
/*
    学生测试类
*/
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new  Student();
        
        //使用set方法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);
        
        s.show();
        
        //使用get方法获取成员变量的值
        System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getName() + "," + s.getAge());
    }
}

    • 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
    • 44
    • 45
    • 46

    4.2 private的使用

    1 ）需求：定义标准的学生类，要求name和age使用private修饰，并提供set和get方法，以及便于显示数据的show方法，测试中创建对象并使用，最终控制台输出：林青霞 ，30

    2 ）实例代码：

    /*
学生类
*/
class Student {
    //成员变量
    private String name;
    private int age;
    
    // get,set 方法
    public void setName(String n) {
        name = n;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public void show() {
        System.out.println(name + "," + age);
    }
}

    • 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
    /*
学生类测试类
*/
​
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        
        //使用 get,set方法
        s.setName("林青霞");
        s.setAge(30);
        
        s.show();
        
        //使用get方法获取成员变量的值
        System.out.print(s.getName() + "---" + s.getAge());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    4.3 this关键字

    1 ）this 修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题 ）

    1. 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
    2. 方法的形参没有与成员变量同名，不带this修饰的变量是指成员变量
    public class Student {
    
    private String name;
	private int age;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName( ) {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge( int age) {
        this.age = age;
    }
    
    public void show() {
        System.out.println(name + "," + age);
    }
}

    • 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

    4.4 this 内存原理

    1 ）this 代表当前调用方法的引用，那个对象调用的方法，this就代表那个对象

    2 ）实例代码：

    public class StudentDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("林青霞");
        Student s2 = new Student();
        s2.setName("张曼玉");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    4.5 封装思想

    1 ）封装概述是 面向对象三个特征之一（封装，继承，多态）是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

    2 ）封装原则 将类的某些信息隐藏在内部，不允许外部程序员直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量 private ，提供对应的getXXX() / setXxx()方法

    3 ）封装好处 通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性

    5. 构造方法

    5.1 构造方法概述

    1 ）构造方法是一种特殊的方法

    2 ）作用：创建对象 Student stu = new Student();

    3 ）格式：

    public class 类名 {
    修饰符 类名(参数) {
        
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5

    4 ）功能：主要是完成对象数据的初始化

    5 ）实例代码：

    /*
学生类
*/
class Student {
    private String name;
    private int age;
    
    //构造方法
    public Student () {
        System.out.println("无参构造方法");
    }
    
    public void show () {
        System.out.println(name + "," + age);
    }
}

/*
学生测试类
*/
public class StudentDemo {
    public static void main(String[] args) {
        // 创建对象
        Student s = new Student();
        s.show();
    }
}

    • 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

    5.2 构造方法的注意事项

    1 ）构造方法的创建

    1. 如果没有定义构造方法，系统将会给出一个默认的无参数构造方法
    2. 如果定义了构造方法，系统将不再提供默认的构造方法

    2 ）构造方法的重载

    1. 如果自定义了带参构造方法，还要使用无参构造方法，就必须再写一个无参构造方法

    3 ）推荐的使用方法

    1. 无论是否使用，都手工书写无参构造方法

    4 ）重要功能

    1. 可以使用带参构造方法，为成员变量进行初始化

    5 ）代码实例

    /*
学生类
*/
class Student {
    private String name;
    private int age;
    
    public Student() {}
    
    public Student(String name) {
        this.name = name;
    }
    
    public Student(int age) {
        this。age = age;
    }
    
    public Student(String name , int age) {
        this.name = name;
        this.age = age;
    }
    
    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
学生测试类
*/
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();
        s1.show();
        
        Student s2 = new Student("林青霞");
        s2.show();
        
        Student s3 = new Student(30);
        s3.show();
        
        Student s4 = new Student("林青霞",30);
        s4.show();
    }
}

    • 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
    • 44
    • 45

    5.3 标准类制作

    需求：

    1. 定义标准学生类，要求分别使用空参数和有结构方法创建对象，
    2. 空参创建的对象通过setXxxx赋值，
    3. 有参创建的对象直接赋值，并通过show方法展示数据

    代码：

    /*
学生类
*/
class Student {
    private String name;
    private int age;
    
    public Student() {}
    
    public Student(String name , int age) {
        this.name = name;
        this.age = age;
    }
    
      public void setName(String name) {
        this.name = name;
    }
    
    public String getName( ) {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge( int age) {
        this.age = age;
    }
    
    public void show() {
        System.out.println(name + "," + age);
    }
    
    /*
学生测试类
*/
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();
        
        //使用带参数的构造方法，创建对象
        Student s2  = new Student("林青霞"，30);
        s2.show();
    

    • 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
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

    🎈看完了不妨给我点个赞吧，👉你的支持，是我每天更新的动力…

  • 相关阅读:
    基于zk的分布式锁使用及原理分析
    使用 Java 解析 Apache 日志文件
    智能算法 | MATLAB实现PSO粒子群算法函数寻优
    LinkedList源码分析
    2022年互联网大厂的中秋仪式感
    TensorFlow入门(二十四、初始化学习参数)
    Python 中的异步请求
    国际物流和跨境电商物流的区别
    集合_Collection_LinkedHashSet简述
    浮点数通信
  • 原文地址：https://blog.csdn.net/weixin_46213083/article/details/126510625