心情： 咳~

笔名： 花美

行业： telecommunication

TIME： 2020-4-15

定义

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

——隐藏对象信息，留出访问接口

特点

只能通过规定的方法访问数据

隐藏类实例细节，方便修改和实现

图形化

实现步骤：

image.png

Code：

class  Cat{
  //修改可见性，只能在类内访问
  private String name;
  public void setName(String name){
  this.name = name;
  }
  public String getName(){
  return this.name;
  }
 } 
  class testCat{
  public static void main(String[] args){
  Cat one = new Cat();
  one.setName("小奶狗");
  System.out.print(one.getName());
  //结果：
  //小奶狗
  }
 }

包

Java中一个包里不可以出现同名的类，所以呢同类名你存在不同包(目录)下就可以了。

命名规则:com.xcb.animal

域名倒序+模块+功能

域名全部小写

package+包名 放在源代码第一行 这句话一个类文件只能有一个

需要功能单一

这里一定要记住： import引入类的时候 这个类在定义时 必须加public修饰</mark>

跨包调用类:加载类顺序与import语句顺序位置无关

 package com.xcb.animal    //声明自己类所属包的名字
 import com.ldh.animal.*   //调用其他包里的所有类  用.*,  这样其他包的类你就可以用了
 import com.liudehua.animal.Cat
  /*只调用这个包的 Cat 类，其他类无权使用
  这里就有个问题了
  如果2 3 行这两个包都有cat呢
  那么new cat的时候他就只会加载直接写明Cat的 liudehua包里的cat类*/
  public class Test{
  public static void main(String[] args){
  com.ldh.animal.Cat one = new com.ldh.animal.Cat();
  /*直接调用不需要上边 import了，但是麻烦
  不过也有好处就是上边提到两个都有Cat类的包加载后
  咱们直接标出包名就准确加载自己要的类了 */
  }
  }

static关键字

1586748775350.png

static：静态的，可以修饰方法，指为在计算机内部单独开辟出一块内存地址

public static int number | public static void run(){};

该类所有对象共用的区域(en~，咳咳!!!!!)

类加载是产生，类彻底销毁时释放，生命周期长

特征：

无论这个类实例化多少个对象，这个static静态成员都会共用同一块静态空间，也就是谁最后赋值即便他是不同对象对他的引用，他的值都是和最后一个引用的赋值一样。

不依赖对象进行访问类名.方法()；or 类名.属性();访问

• static + 类的函数内的局部变量 是不可行的；public Cat(){static int temp = 11;}错误！

• static + 类名 是不可行的public static Cat(){} 错误！

(测试类)访问方式：

one.number = 1;//对象.成员
 one.run();
 Cat.number = 2;//类.成员 推荐这种 方便你观察他的 特殊定义！！！
 Cat.run();

(定义类)书写方式：

 class Cat {
  public static int number;// 静态属性，类属性
 ​
  public Cat() {
  System.out.print("do!!!!");
  }
 ​
  public void run() {
  doooo();// 这里调用静态方法
  }
 ​
  public static void doooo()// 静态方法，类方法
  {

  //run();  这里是不可以调用的 除非run()方法定义时候加个static  是他俩都成为静态方法
  //this.number;    冲突  静态方法不可直接访问同一类内非静态成员
  System.out.print("do");

  //如果你就想调用 看这里：代码块static{} 同理
  Cat temp = new Cat();
  temp.run();
  temp.number = 100;

  }
 }
  class wtestCat {
  public static void main(String[] args) {
  Cat one = new Cat();
  Cat.doooo();//直接执行静态方法
  one.run();

 ​
  }
 }

代码块 {}

普通代码块(函数内的{})：顺序执行——先出现，限执行

构造代码块(函数外类内{})：对象实例化时候 调用，(无论在类内函数外的任何位置中)优先级都高于 构造方法。先执行

静态代码块：虚拟机 static特点，最先执行楼！

甭废话了看代码:

package com;
 ​
 public class Cat {
  public static int number;// 静态成员，类成员
  {
  System.out.print("\n构造代码块1");
  }
 ​
  public Cat() {
  System.out.print("do!!!!");
  }
 ​
  public void run() {
  doooo();
  }
 ​
  public static void doooo()// 静态方法，类方法
  {
  {
  System.out.print("普通代码块1");
  }
  System.out.print("do");
  {
  System.out.print("普通代码块2");
  }
 ​
  }
 ​
  {
  System.out.print("构造代码块2");
  }
  static  {
  System.out.print("静态代码块！\n");
  }
 }
 ​
 class wtestCat {
  public static void main(String[] args) {
  Cat.number = 12312313131;
  System.out.print(Cat.number);
  Cat one = new Cat();
  Cat.doooo();

  //结果：
  // 静态代码块！
  // 12312313131
  //构造代码块1构造代码块2do!!!!普通代码块1do普通代码块2
 ​
  }
 }

作用空间

public void run(String name) {
 {
  int temp= 12;//局部作用域  {}执行完 生命周期结束 变量被回收
 System.out.print("\n构造代码块1");
 }

  //因为外部number没有被定义所以这里 出错显示没有被定义
  System.out.print("\n构造代码块1"+temp);

 {  int temp= 13; //所以他和上边分别作用两个代码块中两个空间 不影响
 System.out.print("\n构造代码块2");
 }
 }

image.png

public void run(String name) {
 {
  int temp= 12;
 System.out.print("\n构造代码块1");
 }

  int temp = 14;
  System.out.print("\n构造代码块1"+number);

 {  int temp= 13; //此时number被重复定义
 System.out.print("\n构造代码块2");
 }
 }

temp=14 生命周期：从定义开始到结束 成为相对于{}的全局变量

image.png

咳咳, Coding！ ——封装案例

主要用于熟悉封装思想 接口暴露与对象当作参数时候的内嵌调用

类的分析：

专业： 专业名称，编号，学制年限 ——图1

学生： 姓名，学号，性别，年龄 —— 图2

image.png

image.png

 package com;
 ​
 class Student {
  private String studentNumber;
  private String studentName;
  private String studentSex;
  private String studentAge;
  private Subject studentSubject;
 ​
  public Student() {
 ​
  }
 ​
  public Student(String studentName, String studentNumber, String studentSex, String studentAge) {
  this.setStudentNumber(studentNumber);
  this.setStudentName(studentName);
  this.setStudentSex(studentSex);
  this.setStudentAge(studentAge);
  }
 ​
  public Student(String studentName, String studentNumber, String studentSex, String studentAge,
  Subject studentSubject) {
  this.setStudentNumber(studentNumber);
  this.setStudentName(studentName);
  this.setStudentSex(studentSex);
  this.setStudentAge(studentAge);
  this.setStudentSubject(studentSubject);
  }
 ​
  public Subject getStudentSubject() {
  if (this.studentSubject == null)
  this.studentSubject = new Subject();
  return this.studentSubject;
  }
 ​
  public void setStudentSubject(Subject studentSubject) {
  this.studentSubject = studentSubject;
  }
 ​
  public String getNumber() {
  return studentNumber;
  }
 ​
  public String getName() {
  return studentName;
  }
 ​
  public String getSex() {
  return studentSex;
  }
 ​
  public String getAge() {
  return studentAge;
  }
 ​
  public void setStudentNumber(String studentNumber) {
  this.studentNumber = studentNumber;
  }
 ​
  public void setStudentName(String studentName) {
  this.studentName = studentName;
  }
 ​
  public void setStudentSex(String studentSex) {
  this.studentSex = studentSex;
  }
 ​
  public void setStudentAge(String studentAge) {
  this.studentAge = studentAge;
  }
 ​
  public String intro() {
  String str = "学生信息是：\n姓名：" + getName() + "\n学号：" + this.getNumber() + "\n性别：" + this.getSex() + "\n年龄："
  + this.getAge() + "\n所报专业：" + this.getStudentSubject().getSubjectName() + "\n专业年限"
  + getStudentSubject().getSubjectLife();
  return str;
  }
 ​
 }
 ​
 class Subject {
  private String subjectName;
  private String subjectNumber;
  private int subjectLife;
  private Student[] students;
  private int stuNumber = 0;
 ​
  public Subject() {
 ​
  }
  // 专业信息初始化——录入
 ​
  public Subject(final String subjectName, final String subjectNumber, final int subjectLife) {
  this.setSubjectName(subjectName);
  this.setSubjectNumber(subjectNumber);
  this.setSubjectLife(subjectLife);
 ​
  }
 ​
  public Subject(final String subjectName, final String subjectNumber, final int subjectLife, Student[] students) {
  this.setSubjectName(subjectName);
  this.setSubjectNumber(subjectNumber);
  this.setSubjectLife(subjectLife);
  this.setstudents(students);
 ​
  }
 ​
  public int getstuNumber() {
  return stuNumber;
  }
 ​
  public void setstuNumber(int stuNumber) {
  this.stuNumber = stuNumber;
  }
 ​
  public Student[] getstudents() {
  if (this.students == null)
  this.students = new Student[100];
  return students;
  }
 ​
  public void setstudents(Student[] students) {
  this.students = students;
  }
 ​
  public void setSubjectName(final String subjectName) {
  this.subjectName = subjectName;
  }
 ​
  public String getSubjectName() {
  return this.subjectName;
  }
 ​
  public void setSubjectNumber(final String subjectNumber) {
  this.subjectNumber = subjectNumber;
  }
 ​
  public String getSubjectNumber() {
  return this.subjectNumber;
  }
 ​
  public void setSubjectLife(final int subjectLife) {
  if (subjectLife <= 0)
  return;
  this.subjectLife = subjectLife;
  }
 ​
  public int getSubjectLife() {
  return this.subjectLife;
  }
 ​
  // 返回专业信息
 ​
  public String info() {
  final String str = "专业信息看下边：\n专业名称：" + this.getSubjectName() + "\n专业编号：" + this.getSubjectNumber() + "\n学年限制："
  + this.getSubjectLife() + "年";
  return str;
  }
 ​
  // 计数：
  public void addstu(Student stu) {
  for (int i = 0; i < this.getstudents().length;i++) {
  if(getstudents()[i]==null){
  this.getstudents()[i] = stu;
  this.stuNumber = i + 1;
  return;//结束方法
  }
  }
 ​
  }
 ​
 }
 ​
 class test {
 ​
  public static void main(String[] args) {
 ​
  Subject sub1 = new Subject("计算机", "A001", 4);
  System.out.println(sub1.info());
  System.out.println("=============================================");
  Student stu1 = new Student("张三", "s01", "男", "18岁");
  System.out.println(stu1.intro());
  System.out.println("=============================================");
  Student stu2 = new Student("李四", "s01", "男", "18岁", sub1);
  System.out.println(stu2.intro());
  System.out.println("=============================================");
  sub1.addstu(stu1);
  sub1.addstu(stu2);
  System.out.println(sub1.getSubjectName()+"专业有"+sub1.getstuNumber()+"在学习");
  //结果：
  // 专业信息看下边：
  // 专业名称：计算机
  // 专业编号：A001
  // 学年限制：4年
  // =============================================
  // 学生信息是：
  // 姓名：张三
  // 学号：s01
  // 性别：男
  // 年龄：18岁
  // 所报专业：null
  // 专业年限0
  // =============================================
  // 学生信息是：
  // 姓名：李四
  // 学号：s01
  // 性别：男
  // 年龄：18岁
  // 所报专业：计算机
  // 专业年限4
  // =============================================
  // 计算机专业有2在学习
  }
 }