0. 面向对象

面向对象（Object-Oriented）是一种软件开发方法，其概念和应用已经超越了程序设计和软件开发。面向对象是一种对现实世界理解和抽象的方法。

引用自百度百科。

面向对象编程：OOP(Object-Oriented Programming)。

1. Java中的对象

概念

• 类（模板）：class，用于定义同种类型对象所包含的状态（变量）与行为（方法）。
• 对象（实例）：instance，具体的某一个对象，具有实际的状态和行为。

Java程序中，通过各种类与对象的互相作用实现了我们所要完成的功能。

2. 类与对象

2.1 基本使用

2.1.1 声明类

使用class关键字来声明一个类。

/**
*  声明一个类，类名为Person。
*  类中包含了两个变量，name和age，代表类的状态。
*  其中sayHello是类的方法，代表类的行为。
*/
public class Person {
   
    public String name;
    public int age;
    
    // 方法sayHell会在屏幕上打印 Hello, I`m 名字。
    public void sayHello(){
        System.out.println("Hello, I`m + ", + this.name);
    }
}

2.1.2 创建对象

使用new关键字来创建一个类的对象。

// 下面创建了两个对象，并把他们的引用分别赋给zhang和li这两个变量。
Person zhang = new Person();
zhang.name = "张三";
zhang.age = 25;
Person li = new Person();
li.name = "李四";
li.age = 30;

2.1.3 使用对象

点操作符（"."）可以用来访问对象或类的变量或方法。

// 打印张三的名字。
System.out.println(zhang.name);
// 调用sayHello方法。调用方法需要在方法名后使用()来指定调用方法的参数，sayHello没有定义参数，所以这里不传递参数。
zhang.sayHello();

2.2 类的结构

这里先不讨论public、private、protected等限制访问权限的关键字。等介绍完包、继承等概念之后，在来详细介绍关于限制访问权限的这些关键字对类中成员的影响。

2.2.1 类的变量（field）

变量又叫域。

类中的变量有三种类型：

public class Person{
    // 类变量，通过Person.count访问。
    public static int count;
    // 成员变量，通过 对象.name访问。
    public String name;
    
    {
        // 局部变量，方法块结束后无法访问。
        int a;
    }
}

注意事项

• 关于重名：对于在同一作用域中重名的变量，局部变量会覆盖其他范围的同名变量，我们可以采用如下方法区别。

  ![Java-方法](C:\Users\cxhao\Pictures\Java-方法.png)public class Test {
  
      // 使用【 类名.变量名 】表示类变量
      public static int i = 5;
      static {
          int i = 10;
          System.out.println(Test.i);
      }
      // 在类的内部，使用【 this.变量名 】表示成员变量
      public int j = 50;
      public void print(){
          int j = 0;
          System.out.println(this.j);
      }
  
      public static void main(String[] args) {
          Test test = new Test();
          test.print();
  		// 在类的外部使用【 实例.变量名 】表示该实例的成员变量
          int j = 10;
          System.out.println(test.j);
      }
  }
  

2.2.2 类的方法（method）

方法又叫函数。

public class Person {

    public String name;

    public int age;

    public void sayHello() {
        System.out.println("Hello! My name is " + this.name + ". I`m " + this.age);
    }

    public String sayGoodbyeTo(String name){
        return "Goodbye " + name + " !";
    }

    public static void main(String[] args) {
        Person zhang = new Person();
        zhang.name = "张三";
        zhang.age = 28;
        Person li = new Person();
        li.name = "李四";
        li.age = 25;

        zhang.sayHello();
        li.sayHello();
        System.out.println(zhang.sayGoodbyeTo(li.name));
    }
}

定义方法的形式

[修饰符] 返回值类型 方法名称(参数列表) [throws Exception]{
?   方法体
?   return 返回值;
}

• 修饰符：可以省略，这里先不介绍。
• 返回值类型：在Java中一个方法，至多有一个返回值，没有返回值时，返回值类型指定为void。
• 方法名称：遵守小驼峰命名规则。
• 参数列表：Java中的方法可以有0到多个参数。
• throws Exception：方法可能抛出的异常。
• 方法体：方法为了完成特定功能需要执行的代码。
• 返回值：方法返回的值，类型必须与指定的返回值类型相同，没有返回值时，return;(也可以省略不写)。

使用方法

类名或实例名.方法名(实际参数);

方法的结束

方法在执行到return语句、"}"或抛出异常时结束。

2.2.3 构造方法

构造方法的形式

[访问限制修饰符] 类名(参数列表){
	方法体
}

public class Person {

    public String name;

    public int age;

    // 空构造函数
    public Person() {
    }

    // 构造方法的名字必须与类名相同
    public Person(String name) {
        this(name, 22);
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {
        Person zhang = new Person("张三");
        Person li = new Person("李四", 25);

        System.out.println(zhang);
        System.out.println(li);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }
}

• 每个类都必须有至少一个构造函数，当且仅当类中没有显式的指定构造函数时，Java编译器会添加一个默认的构造函数。
• this关键字，在构造函数中，表示调用当前类的其他构造函数（根据参数列表匹配）。
• 可以定义多个构造方法，编译器会根据参数列表判断调用哪个构造方法。

3. 面向对象特性

3.1 封装

封装：将一个对象的状态（变量）和与这些状态相关的行为（方法）组装到一起。

• 封装的基本单位是对象，“高内聚、低耦合”是面向对象技术的封装性所需要实现的最基本的目标。·

• 对于用户（调用方）来说，对象内部如何进行操作和实现并不重要，用户只需要关心对象对外暴露的接口（方法）。

• 使用private对变量（状态）进行保护，提供公共方法（行为），供用户修改实例的变量。

      private String name;
  
      private int age;
  
      public String getName() {
          return name;
      }
  
      // 在入口对数据形成处理。trim()方法可以删除两边多余的空格
      public void setName(String name) {
          this.name = name.trim();
      }
  
      public int getAge() {
          return age;
      }
  
      public void setAge(int age) {
          this.age = age;
      }
  

3.2 继承

继承：是一种代码复用的方式。

Java中使用关键字extends来实现继承的功能。

其中被继承的类叫做超类（super）也叫父类或基类。

继承父类的类叫做子类（subclass）也叫扩展类。

// 父类
public class Person {

    private String name;

    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void sayHello() {
        System.out.print("Hello! My name is " + name + " .I`m " + age + ".");
    }
    // 方法重载
    public void sayHello(String name){
        System.out.print("Hello, " + name + "! My name is " + this.name + " .I`m " + age + ".");
    }
}
// 子类
public class Student extends Person {
    private int grade;

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }

    public Student(String name, int age, int grade){
        super(name, age);
        this.grade = grade;
    }

    // 方法覆写
    @Override
    public void sayHello(){
        System.out.println();
        super.sayHello();
        System.out.print("I`m in " + grade + " grade.");
    }
}

public class Test {
    public static void main(String[] args) {
        Person zhang = new Person("张三", 28);
        Student ming = new Student("小明", 12, 6);
        zhang.sayHello();
        ming.sayHello();
    }
}

• 如果不显式指定继承的类，则继承Object类，Object类是Java中所有类的顶级父类。
• Java中一个类只能指定一个父类。
• super代表父类，在子类的构造方法中，第一句必须是调用父类的构造方法；在方法中可以通过super来调用父类的方法。

3.3 多态（Polymorphic）

在Test类中，我们将Student类型的实例赋给Person类型的变量，但在运行的过程中，实际执行的是Student类的sayHello()方法。

一个名称（父类型变量）可以表示很多不同类的对象（子类实例），这些类都是同一个父类。这个名称（变量）表示的任何对象可以用不同的方式响应一些共同的操作集合。这个行为就做多态。

Java通过方法覆写和向上转型来实现多态。

3.3.1 方法覆写（Override）

在子类中定义与父类方法签名相同的方法，会覆盖父类中的方法。在实际执行的过程中，会执行子类中的方法。例如：Student类覆写了Person的sayHello方法。

• 在覆写的方法上加上@Override可以让编译器帮助我们检查该方法是否覆写了父类的方法。

3.3.2 向上转型

因为Student类继承自Person类，所以Student是Person类的一种。

所以Person类型的变量可以安全的持有Student类型的实例，即向上转型。例如将Student类型的实例，赋给Person类型的变量ming。

同时因为ming持有的变量的实际类型是Student类的，所以我们可以通过强制类型转换将其赋给Student类型的变量。

Student xiaoming = ming instanceof Student ? (Student) ming: null;

其中，instanceof关键字能够判断一个实例是否是某种类型。

ming instanceof Student;//true
ming instanceof Person;//true

Java_3.面向对象基础

原文：https://www.cnblogs.com/keathBlog/p/12828591.html