封装的实现

封装的概念

  • 将类的某些信息隐藏在类内部，不允许外部程序直接访问
  • 通过该类提供的方法来实现对隐藏信息的操作和访问
  • 隐藏对象的信息
  • 留出访问的接口

封装的特点

  • 只能通过规定的方法访问数据
  • 隐藏类的实现细节，方便修改和实现

封装的实现

image.png

cat.java
#Alt + Shift + S => Generate Getters and Setters：生成类的set 和 get方法

  1. package com.demo;
  3. /**
  4.  * @author 宠物猫类
  5.  *
  6.  */
  7. public class Cat {
  8.     private String name;
  9.     private int age;
  10.     private double weight;
  11.     private String species;
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public int getAge() {
  22.         return age;
  23.     }
  25.     public void setAge(int age) {
  26.         if (age > 0) {
  27.             this.age = age;
  28.         }
  29.     }
  31.     public double getWeight() {
  32.         return weight;
  33.     }
  35.     public void setWeight(double weight) {
  36.         this.weight = weight;
  37.     }
  39.     public String getSpecies() {
  40.         return species;
  41.     }
  43.     public void setSpecies(String species) {
  44.         this.species = species;
  45.     }
  47. }

catTest.java

  1. package com.demo;
  3. public class CatTest {
  4.     public static void main(String[] args) {
  5.         // 对象实例化
  6.         Cat cat1 = new Cat();
  8.         cat1.setName("kitty");
  9.         cat1.setAge(2);
  10.         cat1.setWeight(2.5);
  11.         cat1.setSpecies("中华田园猫");
  13.         System.out.println(cat1.getName());
  14.         System.out.println(cat1.getAge());
  15.         System.out.println(cat1.getWeight());
  16.         System.out.println(cat1.getSpecies());
  17.     }
  18. }

使用包进行类管理

作用：管理Java文件，解决同名文件冲突问题

创建包

  • 一个包里不能存在同名类
  • 包的命名规则：域名倒序 + 模块 + 功能 #域名全部小写
  • 定义包的语句，必须放在Java源文件中的第一行
  • 建议每个包内存储信息功能单一，即单一职责原则

导入包

  • 建议采用”import 包名.类名”的方式加载，提高效率
  • 加载类的顺序跟import导入语句的位置无关
  • “ import 包名.* “ 只能访问指定包名下的类，无法访问子包下的类

导入所有的类

  1. package com.imooc; // 定义包
  2. import com.demo.*; // 导入com.demo下所有的类
  4. public class HelloImooc {
  6.     public static void main(String[] args) {
  7.         Cat cat1 = new Cat();
  8.         CatTest cat2 = new CatTest();
  9.     }
  10. }

导入指定的类

  1. package com.imooc; // 定义包
  3. import com.demo.Cat;        // 导入com.demo下指定的类
  4. import com.demo.CatTest;    // 导入com.demo下指定的类
  6. public class HelloImooc {
  8.     public static void main(String[] args) {
  9.         Cat cat1 = new Cat();
  10.         CatTest cat2 = new CatTest();
  11.     }
  12. }

导入不同包中同名的类

  1. package com.imooc; // 定义包
  3. import com.demo.*; // 导入com.demo下所有的类
  4. import com.dev.*;  // 导入com.dev下所的类
  6. public class HelloImooc {
  8.     public static void main(String[] args) {
  9.         com.demo.Cat cat1 = new com.demo.Cat();
  10.         com.dev.Cat cat2 = new com.dev.Cat();
  11.     }
  12. }

image.png

static关键字

静态属性和静态方法

  • 类对象共享
  • 类加载时产生，销毁时释放，生命周期长，即所有的类对象销毁时释放
  • static + 属性，称之为类属性 / 静态属性
  • static + 方法，称之为类方法 / 静态方法
  • 推荐调用静态属性/方法的方式是，类名.静态成员
  • 静态方法中不能直接访问非静态成员，只能直接调用静态成员

image.png

静态代码块和构造代码块

  • 静态代码块：类加载时调用，优于构造代码块执行
  • 构造代码块：创建对象时调用，优于构造方法执行
  • 在类中可以有多个静态代码块和构造代码块
  • 无论产生多少类实例，静态代码块只执行一次

Cat.java

  1. package com.demo;
  3. /**
  4.  * @author 宠物猫类
  5.  *
  6.  */
  7. public class Cat {
  8.     private String name;
  9.     private int age;
  10.     private double weight;
  11.     private String species;
  13.     public Cat(){
  14.         System.out.println("demo - cat");
  15.     }
  17.     static{
  18.         System.out.println("我是静态代码块1");
  19.     }
  21.     static{
  22.         System.out.println("我是静态代码块2");
  23.     }
  25.     {
  26.         System.out.println("我是构造代码块1");
  27.     }
  29.     {
  30.         System.out.println("我是构造代码块2");
  31.     }
  33.     public String getName() {
  34.         return name;
  35.     }
  36.     ...省略...
  37. }

CatTest.java

  1. package com.demo;
  3. public class CatTest {
  4.     public CatTest(){
  5.         System.out.println("demo - CatTest");
  6.     }
  8.     public static void main(String[] args) {
  9.         // 对象实例化
  10.         Cat cat1 = new Cat();
  11.         Cat cat2 = new Cat();
  12.     }
  13. }

输出结果：
我是静态代码块1
我是静态代码块2

我是构造代码块1
我是构造代码块2
demo - cat

我是构造代码块1
我是构造代码块2
demo - cat

实例：
model - Subject.java

  1. package com.imooc.model;
  3. /**
  4.  * 专业类
  5.  * 
  6.  * @author 57681
  7.  *
  8.  */
  9. public class Subject {
  10.     // 成员属性：专业名称，专业编号，学制年限
  11.     private String subjectName;
  12.     private String subjectNo;
  13.     private int subjectLife;
  14.     private Student[] myStudents;
  15.     private int studentNum;
  17.     // 无参构造方法
  18.     public Subject() {
  19.     }
  21.     // 带参构造方法，实现对属性专业名称，专业编号，学制年限的赋值
  22.     public Subject(String subjectName, String subjectNo, int subjectLife) {
  23.         this.setSubjectName(subjectName);
  24.         this.setSubjectNo(subjectNo);
  25.         this.setSubjectLife(subjectLife);
  26.     }
  28.     // 带参构造方法，实现对属性的全部赋值
  29.     public Subject(String subjectName, String subjectNo, int subjectLife, Student[] myStudents) {
  30.         this.setSubjectName(subjectName);
  31.         this.setSubjectNo(subjectNo);
  32.         this.setSubjectLife(subjectLife);
  33.         this.setMyStudents(myStudents);
  34.     }
  36.     public String getSubjectName() {
  37.         return subjectName;
  38.     }
  40.     public void setSubjectName(String subjectName) {
  41.         this.subjectName = subjectName;
  42.     }
  44.     public String getSubjectNo() {
  45.         return subjectNo;
  46.     }
  48.     public void setSubjectNo(String subjectNo) {
  49.         this.subjectNo = subjectNo;
  50.     }
  52.     public int getSubjectLife() {
  53.         return subjectLife;
  54.     }
  56.     // 设置学制年限，限制必须大于0
  57.     public void setSubjectLife(int subjectLife) {
  58.         if (subjectLife > 0) {
  59.             this.subjectLife = subjectLife;
  60.         }
  61.     }
  63.     /**
  64.      * 获取选修专业的学生信息，如果保存学生信息的数组未被初始化，则初始化长度为200
  65.      * 
  66.      * @return
  67.      */
  68.     public Student[] getMyStudents() {
  69.         if (myStudents == null) {
  70.             myStudents = new Student[200];
  71.         }
  72.         return myStudents;
  73.     }
  75.     public void setMyStudents(Student[] myStudents) {
  76.         this.myStudents = myStudents;
  77.     }
  79.     public int getStudentNum() {
  80.         return studentNum;
  81.     }
  83.     public String info() {
  84.         return "专业名称:" + this.getSubjectName() + "\n专业编号:" + this.getSubjectNo() + "\n学制年限:" + this.getSubjectLife();
  85.     }
  87.     public void addStudent(Student stu) {
  88.         // 1.将学生保存到数组
  89.         // 2.将学生个数保存到studengNum
  90.         for (int i = 0; i < this.getMyStudents().length; i++) {
  91.             if (this.getMyStudents()[i] == null) {
  92.                 stu.setStudentSubject(this);
  93.                 this.getMyStudents()[i] = stu;
  94.                 this.studentNum = i + 1;
  95.                 return;
  96.             }
  97.         }
  98.     }
  99. }

model - Student.java

  1. package com.imooc.model;
  3. /**
  4.  * 学生类
  5.  * 
  6.  * @author 57681
  7.  *
  8.  */
  9. public class Student {
  10.     // 成员属性：学号，姓名，性别，年龄
  11.     private String studentNo;
  12.     private String studentName;
  13.     private String studentSex;
  14.     private int studentAge;
  15.     private Subject studentSubject;
  17.     // 无参构造方法
  18.     public Student() {
  19.     }
  21.     // 带参构造方法，实现对属性学号，姓名，性别，年龄的赋值
  22.     public Student(String studentNo, String studentName, String studentSex, int studentAge) {
  23.         this.setStudentNo(studentNo);
  24.         this.setStudentName(studentName);
  25.         this.setStudentSex(studentSex);
  26.         this.setStudentAge(studentAge);
  27.     }
  29.     // 带参构造方法，实现对属性的全部赋值
  30.     public Student(String studentNo, String studentName, String studentSex, int studentAge, Subject studentSubject) {
  31.         this.setStudentNo(studentNo);
  32.         this.setStudentName(studentName);
  33.         this.setStudentSex(studentSex);
  34.         this.setStudentAge(studentAge);
  35.         this.setStudentSubject(studentSubject);
  36.     }
  38.     public String getStudentNo() {
  39.         return studentNo;
  40.     }
  42.     public void setStudentNo(String studentNo) {
  43.         this.studentNo = studentNo;
  44.     }
  46.     public String getStudentName() {
  47.         return studentName;
  48.     }
  50.     public void setStudentName(String studentName) {
  51.         this.studentName = studentName;
  52.     }
  54.     public String getStudentSex() {
  55.         return studentSex;
  56.     }
  58.     public void setStudentSex(String studentSex) {
  59.         if (studentSex == "男" || studentSex == "女") {
  60.             this.studentSex = studentSex;
  61.         } else {
  62.             this.studentSex = "男";
  63.         }
  64.     }
  66.     public int getStudentAge() {
  67.         return studentAge;
  68.     }
  70.     public void setStudentAge(int studentAge) {
  71.         if (studentAge < 10 || studentAge > 100) {
  72.             this.studentAge = 18;
  73.         } else {
  74.             this.studentAge = studentAge;
  75.         }
  76.     }
  78.     /**
  79.      * 获取专业对象，如果没有实例化，先实例化后再返回
  80.      * 
  81.      * @return 专业对象信息
  82.      */
  83.     public Subject getStudentSubject() {
  84.         if (studentSubject == null) {
  85.             studentSubject = new Subject();
  86.         }
  87.         return studentSubject;
  88.     }
  90.     public void setStudentSubject(Subject studentSubject) {
  91.         this.studentSubject = studentSubject;
  92.     }
  94.     /**
  95.      * 学生介绍的方法
  96.      */
  97.     public String info() {
  98.         return "学号:" + this.getStudentNo() + "\n姓名:" + this.getStudentName() + "\n性别:" + this.getStudentSex() + "\n年龄:"
  99.                 + this.getStudentAge() + "\n专业名称:" + this.getStudentSubject().getSubjectName() + "\n专业编号:"
  100.                 + this.getStudentSubject().getSubjectNo() + "\n学制年限:" + this.getStudentSubject().getSubjectLife();
  101.     }
  102. }

test - SchoolTest.java

  1. package com.imooc.test;
  3. import com.imooc.model.*;
  5. public class SchoolTest {
  7.     public static void main(String[] args) {
  8.         Subject sub1 = new Subject("计算机科学与技术", "J0001", 4);
  9.         Student stu1 = new Student("S01", "张三", "男", 20);
  10.         Student stu2 = new Student("S02", "李四", "女", 19);
  11.         Student stu3 = new Student("S03", "王五", "男", 21);
  13.         sub1.addStudent(stu1);
  14.         sub1.addStudent(stu2);
  15.         sub1.addStudent(stu3);
  17.         System.out.println(sub1.getStudentNum());
  18.     }
  19. }