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

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

---

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

一、什么是封装

1.概念：

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

1.1对属性进行封装 

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

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

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

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

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

1.2示例：

class Pig {
 private String name;
 private int age;
 
 //依靠set方法进行赋值了  赋值是没有返回值的
 public void setName (String name) {
  this.name = name;
 }
 //有规律  在赋值的时候 set变量名字  小驼峰的命名规则
 public void setAge (int age) {
  //可以控制变量值的范围 大小
  if (age < 0 || age > 100) {
   this.age = 0;
  } else {
   this.age = age;
  }
  
 }
 //书写get方法
 public String getName() {
  return name;
 }
 public int getAge () {
  return age;
 }
}
public class Demo3 {
 public static void main(String[] args) {
  Pig pig = new Pig();
  pig.setName("猪刚鬣");
  pig.setAge(-90);
  System.out.println(pig.getName() + ":" + pig.getAge());
 }
}

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

二、this关键字 

 1.作用

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

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

class Rabbit {
  String name;
  int age;
 
 public Rabbit(String name, int age) {
  //this();//在调用无参构造
  this.name = name;
  this.age = age;
 }
 public Rabbit() {
  //这个this 就是rabbit1
  System.out.println(this);//代表的当前的对象 打印的是一个内存地址
 }
}
public class Demo6 {
 public static void main(String[] args) {
  Rabbit rabbit1 = new Rabbit();
  System.out.println(rabbit1);

  /**
   * com.qfedu.b_fengzhuang.Rabbit@15db9742 this
   com.qfedu.b_fengzhuang.Rabbit@15db9742 rabbit1

   */
  Rabbit rabbit2 = new Rabbit();
  System.out.println(rabbit2);

  /**
   * com.qfedu.b_fengzhuang.Rabbit@6d06d69c   this
   com.qfedu.b_fengzhuang.Rabbit@6d06d69c   rabbit2 

   */
 }
}

1.2使用this关键字调用属性和方法 

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

1.2.1调用成员变量。在构造方法，在成员方法。 

class Person {
 String name;
 int age;
 
 //验证第一个  this关键字可以在构造方法中调用成员变量
 public Person () {
  this.eat();
  this.name = "狗蛋";
 }
 //验证第二个 this关键在成员方法中调用成员变量
 public void eat () {
  //在方法中可以使用this.变量  
  this.name = "老邢";
  System.out.println(name + "在吃饭");
  this.test();
 }
 public void test () {
  System.out.println("细细打");
 }
 
}
public class Demo1 {
 public static void main(String[] args) {
  Person person = new Person ();
  System.out.println(person.name);
  //person.eat();
 }

}

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

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

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

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

class Dog {
 String name;
 int age;
 public Dog() {
  System.out.println("123");
  //this("styb", 8);
 }
 public Dog(String name, int age) {
  this();
  System.out.println("有参构造");
 }
}
public class Demo2 {
 public static void main(String[] args) {
  //需求：实例化对象dog  要求将有参构造这四个字打印出来
  Dog dog = new Dog("goudan", 12);
  //Dog dog = new Dog();
 }

}

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

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

1.方法的参数

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

class Teacher {
 //command的参数是一个类对象
 public void command (Student stu) {
  stu.coding();
 }
}
class Student {
 String name;
 public void coding () {
  System.out.println(name + "敲代码");
 }
}
public class Demo1 {
 public static void main(String[] args) {
  Student student = new Student();
  student.name = "骚磊";
  Teacher teacher = new Teacher();
  //在teacher方法中去调用student对象的一个方法
  //最终打印的结果是 student类下面的方法
  teacher.command(student);
 }

}

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

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`方法，并在控制台输出结果。通过这种方式，实现了两个类之间的交互和协作。

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

class Person {
 public void feed (Dog dog) {
  dog.eat();
 }
}
class Dog {
 public void eat () {
  System.out.println("狗在吃饭");//牛彩云
 }
}
public class Demo2 {
 public static void main(String[] args) {
  Dog dog = new Dog();
  Person person = new Person();
  person.feed(dog);
 }

}

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

四、多类合作(重点) 

1.什么是多类合作

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

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

class Person1 {
 private String name;
 private Cat1 cat1;//一个类对象可以作为另外一个类的属性来使用
 //碰到private修饰的属性有set和get的想法
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Cat1 getCat1() {
  return cat1;
 }
 public void setCat1(Cat1 cat1) {
  this.cat1 = cat1;
 }
 
}
class Cat1 {
 private String name;
 private char sex;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public char getSex() {
  return sex;
 }
 public void setSex(char sex) {
  this.sex = sex;
 }
 
 
}
public class Demo2 {
 public static void main(String[] args) {
  //要对Person1对象的属性进行赋值
  Person1 person1 = new Person1();
  person1.setName("老万");
  Cat1 cat1 = new Cat1();
  cat1.setName("小万");
  cat1.setSex('母');
  person1.setCat1(cat1);
  //取值
  //通过 人取猫的值
  System.out.println(person1.getName());//获取人的名字
  System.out.println(person1.getCat1());//获取猫对象
  System.out.println(person1.getCat1().getName());//获取猫的名字
  System.out.println(person1.getCat1().getSex());
 }
}

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

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.

//部门类
class Department {
 private String depId;//部门id
 private String deptName;//部门的名字
 private Employee employee;//部们下面的员工
 public String getDepId() {
  return depId;
 }
 public void setDepId(String depId) {
  this.depId = depId;
 }
 public String getDeptName() {
  return deptName;
 }
 public void setDeptName(String deptName) {
  this.deptName = deptName;
 }
 public Employee getEmployee() {
  return employee;
 }
 public void setEmployee(Employee employee) {
  this.employee = employee;
 }
 
 
}
//员工类
class Employee {
 private String name;//员工的名字
 private int age;//员工的年龄
 
 private char sex;//员工的性别

 public String getName() {
  return name;
 }

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

 public int getAge() {
  return age;
 }

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

 public char getSex() {
  return sex;
 }

 public void setSex(char sex) {
  this.sex = sex;
 }
 
 
}
public class Demo1 {
 public static void main(String[] args) {
  //创建Employee对象
  Employee employee = new Employee();
  employee.setName("张三");
  employee.setAge(28);
  employee.setSex('男');
  //先创建部门对象
  Department department = new Department();
  //对department对象属性进行赋值
  department.setDepId("0001");
  department.setDeptName("研发部");
  department.setEmployee(employee);
  //以上是在赋值
  //取值
  //想要部门的id
  System.out.println(department.getDepId());
  //想要获取部门的名字
  System.out.println(department.getDeptName());
  //想要获取部门下面的员工对象,会打印的啥?  会打印的是地址！！！
  System.out.println(department.getEmployee());
  //能够获取出来employe对象了。
  //能不能获取emplopyee对象的属性值呢?
  
  System.out.println("员工的名字:" +department.getEmployee().getName());
  System.out.println("员工的年龄:" + department.getEmployee().getAge());
  System.out.println("员工的性别:" + department.getEmployee().getSex());
 }

}

---

2.

class Adult {
 private String name;//成年人的名字
 private Child child;//成年人下面的孩子对象
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Child getChild() {
  return child;
 }
 public void setChild(Child child) {
  this.child = child;
 }
 
}
class Child {
 private String name;
 private int age;
 private Toy toy;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public Toy getToy() {
  return toy;
 }
 public void setToy(Toy toy) {
  this.toy = toy;
 }
 
}
class Toy {
 private String name;//玩具的名字
 private double price;//玩具的价格
 private String kind;//玩具的种类
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public double getPrice() {
  return price;
 }
 public void setPrice(double price) {
  this.price = price;
 }
 public String getKind() {
  return kind;
 }
 public void setKind(String kind) {
  this.kind = kind;
 }
 
}
public class Demo3 {
 public static void main(String[] args) {
  Toy toy = new Toy();
  toy.setName("骚奥特曼");
  toy.setPrice(67.8);
  toy.setKind("皮套");
  Child child = new Child();
  child.setName("小骚磊");
  child.setAge(1);
  child.setToy(toy);
  Adult saolei = new Adult();
  saolei.setName("骚磊");
  saolei.setChild(child);
  //以上都是在赋值
  //取值
  //需求
  //通过成年人找到孩子的名字
  //saolei.getChild()获取孩子对象 .getName
  System.out.println(saolei.getChild().getName());//获取孩子的名字
  System.out.println(saolei.getChild().getAge());//获取孩子的年龄
  //通过成年人获取玩具的种类 名字 价格的
  System.out.println(saolei.getChild().getToy().getName());
  System.out.println(saolei.getChild().getToy().getKind());
  
 }

}

---

3. 

class Teacher {
 private String name;//老师的姓名
 private char sex;
 private int age;
 //老师下面有很多的学生 Student[] stus = new Student[3];
 private Student[]  student;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public char getSex() {
  return sex;
 }
 public void setSex(char sex) {
  this.sex = sex;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public Student[] getStudent() {
  return student;
 }
 public void setStudent(Student[] student) {
  this.student = student;
 }
 
 
}
class Student {
 private String  name;

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }
 
}
public class Demo2 {
 public static void main(String[] args) {
  Student[] stus = new Student[2];//现在数组是一个空的
  //对数组进行赋值
  Student student = new Student();
  student.setName("骚磊");
  Student student2 = new Student();
  student2.setName("老万");
  stus[0] = student;
  stus[1] = student2;
  //脑海里面 想到stus是一个容器 数组， 里面已经放了两个值了
  //两个对象
  
  Teacher teacher = new Teacher();
  teacher.setName("老邢");
  teacher.setAge(89);
  teacher.setSex('女');
  //现在setStudent的参数是一个数组
  //stus里面有值了 两个对象student
  teacher.setStudent(stus);
  
 //以上都是在赋值
 //取值
  Student[] students = teacher.getStudent();
  for (int i = 0; i < students.length; i++) {
   System.out.println(students[i].getName());
  }
  
 }

}

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

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

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

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