关于java:JavaSE第07篇面向对象之封装

面向对象是一种编程思维，是目前最支流、最无效地解决简单业务逻辑的伎俩，而 Java 就是一门纯正的面向对象编程语言。在 Java 中面向对象相干的概念有很多，比方：封装、继承、多态等。本篇咱们将会开始面向对象编程的局部常识，其中次要有理解面向对象的概念、如何创立类和对象、了解封装、能写出一个规范类。

第一章：意识面向对象

1.1- 面向对象概述（理解）

什么是面向对象？

面向对象是一种 程序设计思维。

程序设计的目标是为了用编程解决事实问题，而面向对象编程的关键在于强调 对象 ，用 什么对象来实现什么性能。

在面向对象程序设计思维中，任何的事物都能够看作对象，也就是咱们常常所说的“万物皆对象”（一部手机、一个人、一条狗等等都能够看做是对象）。

对象是由 属性 和办法 组成的。

• 属性：对象的状态。
• 办法：对象的行为或性能。

比方：一个具体的人就可以看做对象

面向对象编程思维是什么？

面向对象编程思维就是，将真实世界的简单关系，形象为一个个对象，而后由对象之间的分工与单干，实现对真实世界的模仿。（总而言之，就是找对象做事儿）

• 真实世界的简单关系：明确需要
• 形象为一个个对象：划分对象

• 对象之间的分工与单干：

  • 分工：对象的性能
  • 单干：对象之间的关系

面向对象的三大特色

• 封装：封装（encapsulation）就是暗藏对象的属性和实现细节，仅对外公开接口，管制在程序中属性的读取和批改的拜访级别。
• 继承: 继承（inheritance）指的是 子类与父类的关系，子类能够继承父类中的属性和办法
• 多态: 多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现形式即为多态。

对于对象的三大特色，后续会一一逐步开展解说，本篇后续将会解说封装。

1.2- 如何创立和应用对象（记忆）

上述讲到，要面向对象编程，就得找对象做事儿。

找对象的前提，得先有对象。

当初没有对象怎么办？

那就得先创建对象，创建对象的规定，须要先晓得 类 和 对象 的概念及关系。

类

类（class），是 对现实生活中一类具备独特特色的事物的形象形容。

比方，“狗”，“狗”是类，不是一个具体的对象，而是一个形象的名称或概念，泛指世界上“会汪汪叫”、“对客人虔诚”、” 会看家护院 ”、“爱啃骨头”、“有四条腿、两只眼睛、一个鼻子、两只耳朵等”具备这一系列特色的物种的称说。

对象

对象，具备 属性 和办法 的一个具体的实例。

类和对象的关系

类是对象的模板，能够用来形容对象的属性和办法。

对象是类的一个具体实例。对象属于类。

所以，要想创立和应用对象，必须先有类，再通过类创建对象。

定义类的格局

关键字：class

public class 类名 {
    // 成员变量 - 形容对象的属性
    // 成员办法 - 形容对象的办法(和之前定义方法不同的是，要去掉关键字 static)
}

示例：

/* 定义类 */
public class Dog {
  // 成员变量
  String name;
  String type;
  String color;
  // 成员办法
  public void eat(){System.out.println("我喜爱啃骨头");
  }
  public void sound(){System.out.println("汪汪~~~");
  }
}

留神：类名单词的首字母要大写（比方：Dog）

创建对象格局

关键字：new

类名 对象名 = new 类名()

示例：

public class DogTest {public static void main(String[] args) {
    // 创建对象
    Dog wangCai = new Dog();}
}

应用对象

操作成员变量：

• 获取：对象名. 成员变量
• 设置：对象名. 成员变量 = 值

操作成员办法：

• 调用办法：对象名. 成员办法()

示例：

public class DogTest {public static void main(String[] args) {
    // 创建对象
    Dog wangCai = new Dog();
    // 设置对象的属性 - 成员变量
    wangCai.name = "旺财";
    wangCai.color = "黄色";
    wangCai.type = "中华田园犬";
    // 读取对象的属性
    System.out.println("这一条狗的名字：" + wangCai.name);
    System.out.println("这一条狗狗的毛色：" + wangCai.color);
    System.out.println("这一条狗狗的种族：" + wangCai.type);
    // 调用对象的办法
    wangCai.eat();
    wangCai.sound();}
}

留神：

• 类是援用数据类型，而对象就是具体的数据。
• 对象的命名和变量命名规定一样。

1.3- 成员变量的默认值是什么（理解）

1.4- 成员变量和局部变量的区别（了解）

成员变量和局部变量

• 成员变量：定义在类中的办法 外的变量。
• 局部变量：定义在类中的办法 内 的变量或办法的参数（形参）。

区别

1. 地位不同

   • 成员变量，类中，办法外。
   • 局部变量，类中，办法内

2. 作用范畴不同

   • 成员变量，作用范畴 - 类中。
   • 局部变量，作用办法 - 办法中

3. 默认值不同

   • 成员变量，有默认值。
   • 局部变量，没有默认值。并且，应用局部变量时，局部变量必须赋值，否则编译不通过。

4. 内存地位不同

   • 成员变量，堆区
   • 局部变量，栈区

5. 生命周期不同

   • 成员变量，随着对象的创立而创立，随着对象的销毁而销毁。
   • 局部变量，随着办法的调用而创立，随着办法调用结束而销毁。

1.5- 内存图解对象（了解）

一个对象创立并为属性赋值的内存图

Person 类代码

public class Person {
  // 成员变量
  String name;
  int age;
  // 成员办法
  public void eat(){System.out.println("吃饭");
  }
}

PersonTest 类代码

public class PersonTest {public static void main(String[] args) {Person zs = new Person();
    zs.name = "张三";
    zs.age = 10;
  }
}

内存图解：

总结：对象是援用数据类型

一个对象调用办法的内存图

Person 类代码 - 同上

PersonTest 类代码：

public class PersonTest {public static void main(String[] args) {Person zs = new Person();
    zs.name = "张三";
    zs.age = 10;
    // 调用办法
    zs.eat();}
}

内存图解：

总结：调用办法时，办法会入栈执行，执行结束后会出栈。

两个对象调用办法的内存图

Person 类代码 - 同上

PersonTest 类代码：

public class PersonTest {public static void main(String[] args) {Person zs = new Person();
    zs.name = "张三";
    zs.age = 10;
    zs.eat();
    Person ls = new Person();
    ls.name = "李四";
    ls.age = 11;
    ls.eat();}
}

内存图解：

总结

1. new 关键字创建对象时，都会独立开拓空间寄存对象的信息。
2. 所有对象的成员办法都是共享方法区中的 class 文件中的办法（节俭内存）。

第二章：面向对象 - 封装

2.1- 什么是封装（理解）

封装（encapsulation）就是 暗藏对象的属性和实现细节，仅对外公开接口，管制在程序中属性的读取和批改的拜访级别。

封装的能够让代码更加强壮且易于保护，进步程序的安全性。

2.2- 如何实现封装（记忆）

首先，private 关键字润饰成员变量

private 润饰的成员变量，仅可能在本类中应用。

格局：private 数据类型 成员变量名;

而后，对外提供公开的 getXXX/setXXX 办法操作对象的属性

其中，this 关键字，在办法中示意调用办法的对象（调用者）。

在办法中，this 关键字能够辨别成员变量和局部变量，若办法中有局部变量和成员变量同名，在办法中应用 this 关键字调用的变量就是成员变量。

public class Person {
  private String name;
  private int age;

  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 static void main(String[] args) {Person zs = new Person();
        zs.name = "张三";  // 此时外部就会调用 setName 办法，setName 办法中的 this 示意对象 zs
        zs.age = 10;      
        Person ls = new Person();   
        ls.name = "李四";   // 此时外部就会调用 setName 办法，setName 办法中的 this 示意对象 ls
        ls.age = 11;
  }

总结：

• 封装概述 是面向对象三大特色之一（封装，继承，多态）是面向对象编程语言对主观世界的模仿，主观世界里成员变量都是暗藏在对象外部的，外界是无奈间接操作的。
• 封装准则 将类的某些信息暗藏在类外部，不容许内部程序间接拜访，而是通过该类提供的办法来实现对暗藏信息的操作和拜访 成员变量 private，提供对应的 getXxx()/setXxx() 办法
• 封装益处 通过办法来管制成员变量的操作，进步了代码的安全性 把代码用办法进行封装，进步了代码的复用性

2.3- 封装优化 - 构造方法（记忆）

什么是构造方法 -construction

构造方法的特点：

• 与类同名的办法
• 办法润饰没有返回值类型，没有 void。

留神：类默认有一个无参的构造方法。构造方法可重载

public class Person{
    // 无参构造方法
    public Person(){}
}

构造方法的作用

1. 创建对象。

   • 创建对象时，会默认调用类的无参构造方法。

2. 初始化对象的属性值。

   • 能够定义带参数构造方法初始化对象属性

代码：Person 类

public class Person {
  private String name;
  private int age;
  // 无参数构造方法
  public Person() {}
  // 有参数构造方法
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  public void show(){System.out.println("姓名：" + this.name);
    System.out.println("年龄：" + this.age);
  }
}

代码：测试类

public class PersonTest {public static void main(String[] args) {
    //【调用无参构造方法】Person zs = new Person();
    zs.name = "张三";
    zs.age = 10；zs.show(); // 打印后果：姓名：张三  年龄：10
    
    //【调用有参构造方法】Person ls = new Person("李四",12);
    ls.show(); // 打印后果：姓名：李四 年龄：12}
}

构造方法注意事项

• 构造方法的创立

  • 如果没有定义构造方法，零碎将给出一个默认的无参数构造方法
  • 如果定义了构造方法，零碎将不再提供默认的构造方法

• 构造方法的重载

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

• 举荐的应用形式

  • 无论是否应用，都手工书写无参数构造方法

• 重要性能！

  • 能够应用带参结构，为成员变量进行初始化

2.4-JavaBean（理解）

JavaBean 是 Java 语言编写类的一种标准规范。合乎 JavaBean 的类，要求类必须是具体的和公共的，并且具备无参数的构造方法，提供用来操作成员变量的 set 和 get 办法。

    public class 类名 {
        // 成员变量
        // 无参构造方法【必须】// 有参构造方法
        // get/set 办法
        // 成员办法
    }