Java面向对象

对象（Object）是一个应用系统中的用来描述客观事物的实体，是有特定属性和行为（方法）的基本运行单位。是类的一个特殊状态下的实例。对象可以是一个实体、一个名词、一个可以想象为有自己标识的任何东西，可以概括来说：万物皆对象。

类（Class）是Java代码的基本组织模块，使用来描述一组具有共同属性和行为对象的基本原型。是对这组对象的概括、归纳和描述表达。类是对象的模板，它定义了本类对象的所拥有的属性集和行为集，是对一组具有相同属性和相同方法的对象的定义

类和对象之间是抽象与具体的关系。类是一个模板是对一类事物的抽象描述，而对象用于表示现实中该事物的个体。类是在对象之上的抽象，对象则是类的具体化，是类的实例。类必须通过对象才可以使用，而对象中的属性和行为必须在类中定义。

二、什么是封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装优点：

• 1. 良好的封装能够减少耦合。

• 2. 类内部的结构可以自由修改。

• 3. 可以对成员变量进行更精确的控制。

• 4. 隐藏信息，实现细节。

1、修改属性的可见性来限制对属性的访问（一般限制为private），例如：

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

这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

2、对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

public class Person{
    private String name;
    private int age;
    public int getAge(){
        return age;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }
}

这就是封装！

三、什么是构造方法 

1、构造方法的作用

构造方法是一个比较特殊的方法，通过构造方法可以完成对象的创建，以及实例变量的初始化。换句话说：构造方法是用来创建对象，并且同时给对象的属性赋值。

注意：

1. 修饰符列表目前统一写：public。千万不要写public static。
2. 构造方法名和类名必须一致。
3. 构造方法不需要指定返回值类型，也不能写void，写上void表示普通方法，就不是构造方法了。

2、构造方法定义、语法如下：

[修饰符列表] 构造方法名(形式参数列表){
	构造方法体;
	通常在构造方法体当中给属性赋值，完成属性的初始化。
}

3、两种构造方法

     1、不带参数的构造方法，例如：

public class Person{
    private String name;
    private int age;
    
    public person(){
        this.name=name;
    }
    
    public int getAge(){
        return age;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }
}

在此代码中，可以看到有一个是跟类名一致的方法： public Person () { this.name=name ; } ，这就是无参构造方法。

     2、带参数的构造方法

        带参数的构造方法就是在不带参的构造方法上加上参数，例如：

public class Person{
    private String name;
    private int age;
    public Person(String name){
        this.name=name;
    }
 
    public int getAge(){
        return age;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }
}

可以看到在原本的的 public Person(String name) 方法中带了个 String name 参数，这就是所谓的带参构造方法。

4、构造方法怎么调用，使用哪个运算符？

使用new运算符来调用构造方法。

new 构造方法名(实际参数列表);

重点：

        对于实例变量来说，只要你在构造方法中没有手动给它赋值，统一都会默认赋值。默认赋系统值。

四、什么是重载

        重载，从简单说，就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者重载方法。在Java中同一个类中的2个或2个以上的方法可以有同一个名字，只要它们的参数声明不同即可。这种情况下，该方法就被称为重载，这个过程称为方法重载。

1、重载的作用

•  方法重载的主要好处就是不用为了对不同的参数类型或参数个数，而写多个函数。多个函数用同一个名字，但参数表，即参数的个数或(和)数据类型可以不同，调用的时候，虽然方法名字相同，但根据参数表可以自动调用对应的函数。如果我们使用reflector去查看微软写的.net的基类库的话，我们可以发现他使用很多的方法重载，这样我们在调用的时候，就不需要记那么多的方法名称，而是知道了方法的功能就可以直接的给他传递不同的参数，编译器会明确的知道我们调用了哪一个方法。重载比if...else要优雅，减少了if...else部分的代码。
• 重载的最直接作用是方便了程序员可以根据不同的参数个数，顺序，类型，自动匹配方法，减少写过个函数名或方法名的重复步骤。

2、重写和重载之间的关系

        既然聊到了什么是重载？重载的作用？这个话题，那么同样的避不开对于重写的理解，以及重写与重载之间的关系。

3、重载例子：

public class OverloadDemo {
 
    //1. test()方法第一次重载，没有参数
    void test() {
        System.out.println("No parameters");
    }
 
    //2. test()方法第二次重载，一个整型参数
    void test(int a) {
        System.out.println("a: " + a);
    }
 
    //3. test()方法第三次重载，两个整型参数
    void test(int a, int b) {
        System.out.println("a and b: " + a + " " + b);
    }
 
    //4. test()方法第四次重载，一个双精度型参数
    double test(double a) {
        System.out.println("double a: " + a);
        return a * a;//返回a*a的值
    }
}

public class Overload {
   public static void main(String args[]){
        OverloadDemo ob=new OverloadDemo();
        double result;
        ob.test();            //定义的是test()方法
        ob.test(10);             //定义的是test(int a)方法
        ob.test(10,20);            //定义的是test(int a,int b)方法
        result=ob.test(123.23);       //定义的是test(double a)方法
        System.out.println("result of ob.test(123.23): "+result);   //输出result的值
   }
}
 
运行结果：    No parameters
a: 10
a and b: 10 20
double a: 123.23
result of ob.test(123.23): 15185.6329

五、什么是重写

1、重写（Override）概念

• 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
• 重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
• 重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。

• 在Java和其他一些高级面向对象的编程语言中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。 如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

2、重写的作用：

• 重写是为了增强类的重用性和复用性，扩展性；
• 重写是对类中方法的扩充，因为继承用的是父类的东西，重写则不仅得到父类的东西，同时也加入了自己的东西，两全其美。

3、重写的一些特性：

• 重写方法和被重写方法必须具有相同的方法名

• 重写方法和被重写方法必须具有相同的参数列表

• 重写方法的返回值类型必须和被重写方法的返回值类型相同或是其子类

• 重写方法不能缩小被重写方法的访问权限

4、重写例子：

• 父类Animal

package com.example.demo.entity;
 
/**
 * @desc:  父类Animal
 * @author: cao_wencao
 * @date: 2020-11-19 10:07
 */
public class Animal {
 
    public void move(){
        System.out.println("狗可以跑和走");
    }
 
}

• 子类Cat重写父类move()方法

package com.example.demo.entity;
 
/**
 * @desc:  子类Cat重写Animal的move()方法
 * @author: cao_wencao
 * @date: 2020-11-19 10:11
 */
public class Cat extends Animal{
 
    public void move(){
        super.move();
        System.out.println("猫可以跳、可以吃小鱼");
    }
}

• TestAnimal

package com.example.demo.entity;
 
/**
 * @desc:
 * @author: cao_wencao
 * @date: 2020-11-19 10:13
 */
public class TestAnimal {
    public static void main(String[] args) {
        Animal animal = new Animal(); // Animal 对象
        Animal cat = new Cat(); // Cat 对象
 
        //animal.move();// 执行 Animal 类的方法
 
        cat.move();//执行 Cat 类的方法
    }
 
}

• 结果如下：

狗可以跑和走
猫可以跳、可以吃小鱼

六、思维导图： 

---

多多转发、点赞、评论、谢谢大家，让更多人受益！！！