面向对象是一种编程思维，是目前最支流、最无效地解决简单业务逻辑的伎俩，而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办法        // 成员办法    }