• Java学习day07：面向对象三大特性之一：封装

    声明：该专栏本人重新过一遍java知识点时候的笔记汇总，主要是每天的知识点+题解，算是让自己巩固复习，也希望能给初学的朋友们一点帮助，大佬们不喜勿喷(抱拳了老铁！)

    往期回顾

    Java学习day06：面向对象基础，构造方法，成员/局部变量_凌~风的博客-CSDN博客

    Java学习day05：排序，选择、冒泡、快速、二分、杨辉三角-CSDN博客

    Java学习day04：数组（知识点＋习题详解）_凌~风的博客-CSDN博客

    ......

    Java学习day07：面向对象三大特性之一：封装

    一、什么是封装

    1.概念：

    封装是面向对象的思想的特性，主要分为一下四类：
    对属性进行封装   对方法进行封装   对类进行封装  对项目进行封装

    1.1对属性进行封装 

    我们这里就举一个具体讲解：

    写一个类，类下面的成员变量String name;

    只需要通过对象.属性 = 初始化值；进行赋值。这样存在一定的隐患：比如说有人对age赋值1000，数据不符合常规

    这个时候我们就可以对属性进行封装:
    1.对成员变量加修饰符  private 
    2.在类中书写 set和get方法进行对属性的赋值和取值

    private修饰符可以把修饰的变量变成私有的，此时就无法再在main方法里通过对象.变量 进行赋值，而只能用set方法赋值，get方法取值，此时就可以在set方法里限制age的值使其符合规范

    1.2示例：
    1. class Pig {
    2.  private String name;
    3.  private int age;
    4.  
    5.  //依靠set方法进行赋值了  赋值是没有返回值的
    6.  public void setName (String name) {
    7.   this.name = name;
    8.  }
    9.  //有规律  在赋值的时候 set变量名字  小驼峰的命名规则
    10.  public void setAge (int age) {
    11.   //可以控制变量值的范围 大小
    12.   if (age < 0 || age > 100) {
    13.    this.age = 0;
    14.   } else {
    15.    this.age = age;
    16.   }
    17.   
    18.  }
    19.  //书写get方法
    20.  public String getName() {
    21.   return name;
    22.  }
    23.  public int getAge () {
    24.   return age;
    25.  }
    26. }
    27. public class Demo3 {
    28.  public static void main(String[] args) {
    29.   Pig pig = new Pig();
    30.   pig.setName("猪刚鬣");
    31.   pig.setAge(-90);
    32.   System.out.println(pig.getName() + ":" + pig.getAge());
    33.  }
    34. }

    同时记得，除了可以用set方法赋值以外，还可以用有参构造赋值，两个中选一个就行，另外idea中用alt+insert快捷键可以之间创建set和get方法，而且在项目实际开发中，其实都不会写set和get方法，直接就用封装好的 

    二、this关键字 

     1.作用

    1.1.写在类中，代表当前对象：

    可以看到不管是在无参构造里打印的this还是在main方法里打印的对象，最后都是内存地址，且都是一样的 

    1. class Rabbit {
    2.   String name;
    3.   int age;
    4.  
    5.  public Rabbit(String name, int age) {
    6.   //this();//在调用无参构造
    7.   this.name = name;
    8.   this.age = age;
    9.  }
    10.  public Rabbit() {
    11.   //这个this 就是rabbit1
    12.   System.out.println(this);//代表的当前的对象 打印的是一个内存地址
    13.  }
    14. }
    15. public class Demo6 {
    16.  public static void main(String[] args) {
    17.   Rabbit rabbit1 = new Rabbit();
    18.   System.out.println(rabbit1);
    19.  
    20.   /**
    21.    * com.qfedu.b_fengzhuang.Rabbit@15db9742 this
    22.    com.qfedu.b_fengzhuang.Rabbit@15db9742 rabbit1
    23.  
    24.    */
    25.   Rabbit rabbit2 = new Rabbit();
    26.   System.out.println(rabbit2);
    27.  
    28.   /**
    29.    * com.qfedu.b_fengzhuang.Rabbit@6d06d69c   this
    30.    com.qfedu.b_fengzhuang.Rabbit@6d06d69c   rabbit2 
    31.  
    32.    */
    33.  }
    34. }
    1.2使用this关键字调用属性和方法 

    this这个关键只能在方法（成员方法和构造方法）中使用。

    1.2.1调用成员变量。在构造方法，在成员方法。 
    1. class Person {
    2.  String name;
    3.  int age;
    4.  
    5.  //验证第一个  this关键字可以在构造方法中调用成员变量
    6.  public Person () {
    7.   this.eat();
    8.   this.name = "狗蛋";
    9.  }
    10.  //验证第二个 this关键在成员方法中调用成员变量
    11.  public void eat () {
    12.   //在方法中可以使用this.变量  
    13.   this.name = "老邢";
    14.   System.out.println(name + "在吃饭");
    15.   this.test();
    16.  }
    17.  public void test () {
    18.   System.out.println("细细打");
    19.  }
    20.  
    21. }
    22. public class Demo1 {
    23.  public static void main(String[] args) {
    24.   Person person = new Person ();
    25.   System.out.println(person.name);
    26.   //person.eat();
    27.  }
    28.  
    29. }

    注意执行顺序，在main方法里new的时候，就执行了构造方法，而构造方法里又会执行其他方法，同时后执行的会覆盖前面先执行的，把代码执行逻辑理顺就是，没有什么难的

     2.this可以调用当前的构造方法（很少用的！）

     2.1只能在构造方法中去调用构造方法

    只能在构造方法中调用构造方法，而且this（）只能在构造方法中放在第一行
    能不能在成员方法中调用构造方法？不能！！！

    1. class Dog {
    2.  String name;
    3.  int age;
    4.  public Dog() {
    5.   System.out.println("123");
    6.   //this("styb", 8);
    7.  }
    8.  public Dog(String name, int age) {
    9.   this();
    10.   System.out.println("有参构造");
    11.  }
    12. }
    13. public class Demo2 {
    14.  public static void main(String[] args) {
    15.   //需求：实例化对象dog  要求将有参构造这四个字打印出来
    16.   Dog dog = new Dog("goudan", 12);
    17.   //Dog dog = new Dog();
    18.  }
    19.  
    20. }

    此时会先打印123，再换行打印有参构造

    三、类对象作为一个方法的参数

    1.方法的参数

    可以是八大基本数据类型，String，数组，类对象也是可以的

    1. class Teacher {
    2.  //command的参数是一个类对象
    3.  public void command (Student stu) {
    4.   stu.coding();
    5.  }
    6. }
    7. class Student {
    8.  String name;
    9.  public void coding () {
    10.   System.out.println(name + "敲代码");
    11.  }
    12. }
    13. public class Demo1 {
    14.  public static void main(String[] args) {
    15.   Student student = new Student();
    16.   student.name = "骚磊";
    17.   Teacher teacher = new Teacher();
    18.   //在teacher方法中去调用student对象的一个方法
    19.   //最终打印的结果是 student类下面的方法
    20.   teacher.command(student);
    21.  }
    22.  
    23. }

     这段代码的执行逻辑如下：

    1. 首先，在`main`方法中创建了一个`Student`对象，并给其`name`属性赋值为"骚磊"。
    2. 然后，创建了一个`Teacher`对象。
    3. 接下来，调用`Teacher`对象的`command`方法，并将之前创建的`Student`对象作为参数传入。
    4. 在`command`方法中，使用参数`stu`来调用`Student`对象的`coding`方法。
    5. 在`coding`方法中，使用`System.out.println`打印出`name`属性的值以及"敲代码"。
    6. 最终，控制台输出的结果为"骚磊敲代码"。
    总结起来，这段代码的主要逻辑是通过`Teacher`类的`command`方法来调用`Student`类的`coding`方法，并在控制台输出结果。通过这种方式，实现了两个类之间的交互和协作。

    再给大家举个例子，大家自行理解下面这个

    1. class Person {
    2.  public void feed (Dog dog) {
    3.   dog.eat();
    4.  }
    5. }
    6. class Dog {
    7.  public void eat () {
    8.   System.out.println("狗在吃饭");//牛彩云
    9.  }
    10. }
    11. public class Demo2 {
    12.  public static void main(String[] args) {
    13.   Dog dog = new Dog();
    14.   Person person = new Person();
    15.   person.feed(dog);
    16.  }
    17.  
    18. }

    这部分主要是理解，多理解，就是说，把一个类实例化出来的对象，作为一个参数传给了一个方法，这也就意味着，这个方法里可以用对象去调用类相关的属性 

    四、多类合作(重点) 

    1.什么是多类合作

    一个类对象可以当成另外一个类的成员变量
    紧紧围绕者一个点：赋值和取值  只是针对于属性 的

    如果大家有点懵逼的，建议先清楚一下几个概念：类、对象、属性、行为、成员变量、局部变量。想清楚了再回头来看这个知识点

    1. class Person1 {
    2.  private String name;
    3.  private Cat1 cat1;//一个类对象可以作为另外一个类的属性来使用
    4.  //碰到private修饰的属性有set和get的想法
    5.  public String getName() {
    6.   return name;
    7.  }
    8.  public void setName(String name) {
    9.   this.name = name;
    10.  }
    11.  public Cat1 getCat1() {
    12.   return cat1;
    13.  }
    14.  public void setCat1(Cat1 cat1) {
    15.   this.cat1 = cat1;
    16.  }
    17.  
    18. }
    19. class Cat1 {
    20.  private String name;
    21.  private char sex;
    22.  public String getName() {
    23.   return name;
    24.  }
    25.  public void setName(String name) {
    26.   this.name = name;
    27.  }
    28.  public char getSex() {
    29.   return sex;
    30.  }
    31.  public void setSex(char sex) {
    32.   this.sex = sex;
    33.  }
    34.  
    35.  
    36. }
    37. public class Demo2 {
    38.  public static void main(String[] args) {
    39.   //要对Person1对象的属性进行赋值
    40.   Person1 person1 = new Person1();
    41.   person1.setName("老万");
    42.   Cat1 cat1 = new Cat1();
    43.   cat1.setName("小万");
    44.   cat1.setSex('母');
    45.   person1.setCat1(cat1);
    46.   //取值
    47.   //通过 人取猫的值
    48.   System.out.println(person1.getName());//获取人的名字
    49.   System.out.println(person1.getCat1());//获取猫对象
    50.   System.out.println(person1.getCat1().getName());//获取猫的名字
    51.   System.out.println(person1.getCat1().getSex());
    52.  }
    53. }

    这段代码的执行逻辑如下：

    1. 首先，在`main`方法中创建了一个`Person1`对象，并给其`name`属性赋值为"老万"。
    2. 然后，创建了一个`Cat1`对象，并给其`name`属性赋值为"小万"，`sex`属性赋值为'母'。
    3. 接下来，将之前创建的`Cat1`对象作为参数传入`Person1`对象的`setCat1`方法中，将其设置为`Person1`对象的`cat1`属性。
    4. 然后，通过`Person1`对象的`getName`方法获取`name`属性的值，并使用`System.out.println`打印出来。
    5. 通过`Person1`对象的`getCat1`方法获取`cat1`属性的值，即一个`Cat1`对象，并使用`System.out.println`打印出来。
    6.通过`Person1`对象的`getCat1`方法获取`cat1`属性的值，即一个`Cat1`对象，并调用该对象的`getName`方法获取`name`属性的值，并使用`System.out.println`打印出来。
    7.最后，通过`Person1`对象的`getCat1`方法获取`cat1`属性的值，即一个`Cat1`对象，并调用该对象的`getSex`方法获取`sex`属性的值，并使用`System.out.println`打印出来。

    总结起来，这段代码的主要逻辑是通过`Person1`类的对象来设置和获取其属性的值，其中`cat1`属性是一个`Cat1`类的对象。通过调用对象的方法和访问对象的属性，实现了对属性值的设置和获取，并在控制台输出结果。通过这种方式，实现了类与类之间的关联和交互。

    以上就是今天所有的知识点，下面做题：

    五、习题

    1.题目

    1.部门类、员工类、部门类下面有员工

    2.成年人类、孩子类、玩具类

    3.老师类、学生类、老师带了很多学生    把学生存倒数组中 STudent[] stus = new Student[6];

     建议初学者都敲一敲，而且是不看我的答案，先自己敲，很多东西看着会，实际自己上手敲的时候往往会出错。另外题解肯定不止一个，我也只是记录其中一种，大家大可寻找更优解，同时我基本没写注释，希望大家还是多自己思考原因。 

    2.部分习题参考答案

    1.

    1. //部门类
    2. class Department {
    3.  private String depId;//部门id
    4.  private String deptName;//部门的名字
    5.  private Employee employee;//部们下面的员工
    6.  public String getDepId() {
    7.   return depId;
    8.  }
    9.  public void setDepId(String depId) {
    10.   this.depId = depId;
    11.  }
    12.  public String getDeptName() {
    13.   return deptName;
    14.  }
    15.  public void setDeptName(String deptName) {
    16.   this.deptName = deptName;
    17.  }
    18.  public Employee getEmployee() {
    19.   return employee;
    20.  }
    21.  public void setEmployee(Employee employee) {
    22.   this.employee = employee;
    23.  }
    24.  
    25.  
    26. }
    27. //员工类
    28. class Employee {
    29.  private String name;//员工的名字
    30.  private int age;//员工的年龄
    31.  
    32.  private char sex;//员工的性别
    33.  
    34.  public String getName() {
    35.   return name;
    36.  }
    37.  
    38.  public void setName(String name) {
    39.   this.name = name;
    40.  }
    41.  
    42.  public int getAge() {
    43.   return age;
    44.  }
    45.  
    46.  public void setAge(int age) {
    47.   this.age = age;
    48.  }
    49.  
    50.  public char getSex() {
    51.   return sex;
    52.  }
    53.  
    54.  public void setSex(char sex) {
    55.   this.sex = sex;
    56.  }
    57.  
    58.  
    59. }
    60. public class Demo1 {
    61.  public static void main(String[] args) {
    62.   //创建Employee对象
    63.   Employee employee = new Employee();
    64.   employee.setName("张三");
    65.   employee.setAge(28);
    66.   employee.setSex('男');
    67.   //先创建部门对象
    68.   Department department = new Department();
    69.   //对department对象属性进行赋值
    70.   department.setDepId("0001");
    71.   department.setDeptName("研发部");
    72.   department.setEmployee(employee);
    73.   //以上是在赋值
    74.   //取值
    75.   //想要部门的id
    76.   System.out.println(department.getDepId());
    77.   //想要获取部门的名字
    78.   System.out.println(department.getDeptName());
    79.   //想要获取部门下面的员工对象,会打印的啥?  会打印的是地址！！！
    80.   System.out.println(department.getEmployee());
    81.   //能够获取出来employe对象了。
    82.   //能不能获取emplopyee对象的属性值呢?
    83.   
    84.   System.out.println("员工的名字:" +department.getEmployee().getName());
    85.   System.out.println("员工的年龄:" + department.getEmployee().getAge());
    86.   System.out.println("员工的性别:" + department.getEmployee().getSex());
    87.  }
    88.  
    89. }

    2.

    1. class Adult {
    2.  private String name;//成年人的名字
    3.  private Child child;//成年人下面的孩子对象
    4.  public String getName() {
    5.   return name;
    6.  }
    7.  public void setName(String name) {
    8.   this.name = name;
    9.  }
    10.  public Child getChild() {
    11.   return child;
    12.  }
    13.  public void setChild(Child child) {
    14.   this.child = child;
    15.  }
    16.  
    17. }
    18. class Child {
    19.  private String name;
    20.  private int age;
    21.  private Toy toy;
    22.  public String getName() {
    23.   return name;
    24.  }
    25.  public void setName(String name) {
    26.   this.name = name;
    27.  }
    28.  public int getAge() {
    29.   return age;
    30.  }
    31.  public void setAge(int age) {
    32.   this.age = age;
    33.  }
    34.  public Toy getToy() {
    35.   return toy;
    36.  }
    37.  public void setToy(Toy toy) {
    38.   this.toy = toy;
    39.  }
    40.  
    41. }
    42. class Toy {
    43.  private String name;//玩具的名字
    44.  private double price;//玩具的价格
    45.  private String kind;//玩具的种类
    46.  public String getName() {
    47.   return name;
    48.  }
    49.  public void setName(String name) {
    50.   this.name = name;
    51.  }
    52.  public double getPrice() {
    53.   return price;
    54.  }
    55.  public void setPrice(double price) {
    56.   this.price = price;
    57.  }
    58.  public String getKind() {
    59.   return kind;
    60.  }
    61.  public void setKind(String kind) {
    62.   this.kind = kind;
    63.  }
    64.  
    65. }
    66. public class Demo3 {
    67.  public static void main(String[] args) {
    68.   Toy toy = new Toy();
    69.   toy.setName("骚奥特曼");
    70.   toy.setPrice(67.8);
    71.   toy.setKind("皮套");
    72.   Child child = new Child();
    73.   child.setName("小骚磊");
    74.   child.setAge(1);
    75.   child.setToy(toy);
    76.   Adult saolei = new Adult();
    77.   saolei.setName("骚磊");
    78.   saolei.setChild(child);
    79.   //以上都是在赋值
    80.   //取值
    81.   //需求
    82.   //通过成年人找到孩子的名字
    83.   //saolei.getChild()获取孩子对象 .getName
    84.   System.out.println(saolei.getChild().getName());//获取孩子的名字
    85.   System.out.println(saolei.getChild().getAge());//获取孩子的年龄
    86.   //通过成年人获取玩具的种类 名字 价格的
    87.   System.out.println(saolei.getChild().getToy().getName());
    88.   System.out.println(saolei.getChild().getToy().getKind());
    89.   
    90.  }
    91.  
    92. }

    3. 

    1. class Teacher {
    2.  private String name;//老师的姓名
    3.  private char sex;
    4.  private int age;
    5.  //老师下面有很多的学生 Student[] stus = new Student[3];
    6.  private Student[]  student;
    7.  public String getName() {
    8.   return name;
    9.  }
    10.  public void setName(String name) {
    11.   this.name = name;
    12.  }
    13.  public char getSex() {
    14.   return sex;
    15.  }
    16.  public void setSex(char sex) {
    17.   this.sex = sex;
    18.  }
    19.  public int getAge() {
    20.   return age;
    21.  }
    22.  public void setAge(int age) {
    23.   this.age = age;
    24.  }
    25.  public Student[] getStudent() {
    26.   return student;
    27.  }
    28.  public void setStudent(Student[] student) {
    29.   this.student = student;
    30.  }
    31.  
    32.  
    33. }
    34. class Student {
    35.  private String  name;
    36.  
    37.  public String getName() {
    38.   return name;
    39.  }
    40.  
    41.  public void setName(String name) {
    42.   this.name = name;
    43.  }
    44.  
    45. }
    46. public class Demo2 {
    47.  public static void main(String[] args) {
    48.   Student[] stus = new Student[2];//现在数组是一个空的
    49.   //对数组进行赋值
    50.   Student student = new Student();
    51.   student.setName("骚磊");
    52.   Student student2 = new Student();
    53.   student2.setName("老万");
    54.   stus[0] = student;
    55.   stus[1] = student2;
    56.   //脑海里面 想到stus是一个容器 数组， 里面已经放了两个值了
    57.   //两个对象
    58.   
    59.   Teacher teacher = new Teacher();
    60.   teacher.setName("老邢");
    61.   teacher.setAge(89);
    62.   teacher.setSex('女');
    63.   //现在setStudent的参数是一个数组
    64.   //stus里面有值了 两个对象student
    65.   teacher.setStudent(stus);
    66.   
    67.  //以上都是在赋值
    68.  //取值
    69.   Student[] students = teacher.getStudent();
    70.   for (int i = 0; i < students.length; i++) {
    71.    System.out.println(students[i].getName());
    72.   }
    73.   
    74.  }
    75.  
    76. }

    最后再给大家一个题，大家可以尝试做做

    4.
    需求：
     两个宠物一个狗一个猫宠物饿了，需要主人给宠物喂食
     1.不同的宠物吃的不同
     2.不同的宠物吃完食体力值增加
     3.主人和狗玩游戏 接飞盘的游戏。狗体力值减去10，但是会和主人的亲密度提升5
     4.主人和猫玩游戏  滚毛球。猫体力值减去12 ，但是会和主人的亲密度提升7
     
     人类
     猫类 

    以上，就是今天的所有知识点了。今天的知识点要稍微难一点，确实没那么好理解。我当时懂了，也能敲出作业，但是一个国庆没看，现在还不是就又忘记了，今天写这篇文章的时候都比之前速度慢很多，就是没有理解透彻的原因。

    所以大家一定多看多敲多熟悉。 

    加油吧，预祝大家变得更强！

  • 相关阅读:
    MyBatis篇---第一篇
    CURL
    尚硅谷-ShardingSphere
    常见服务知识点罗列--haproxy/keepalived
    电脑启动过程（超详细过程）
    CCF CSP 201403-2 窗口 题解
    产品需求分析师的基本职责（合集）
    高效并发：Synchornized的锁优化详解
    RibbonBar
    基于细节增强的MR序列转换方法
  • 原文地址：https://blog.csdn.net/LF__plus/article/details/133653088