2020-10-11

一、面向对象语言编程

​  Java是一门面向对象的编程语言（OOP），万物皆对象
  面向对象初步认识，在大多数编程语言中根据解决问题的思维方式不同分为两种编程语言
  1、面向过程编程
  2、面向对象编程
  区别：
  面向过程：事物比较简单，可以使用线性思维解决，具体每一个实现步骤清晰可见
  面向对象：事物比较复杂使用简单的线性思维无法解决，存在对象与对象之间的引用
  共同点：
  1、都是为了解决实际问题的一种方式
  2、当解决复杂问题时，面向对象是从宏观角度把握问题的整体，面向过程是从微观角度实现具体细节，两者之间相辅相成

二、Java的面向对象编程

  Java作为面向对象的语言，关于面向对象语言的核心概念

1、类和对象

  类： 一类事物的抽象的模板，在现实世界中 类就是任意一类事物 ，在程序中类就是一个描述这类事物的类文件。
  对象： 在这一类事物中，具体的某一个个体就是对象 ，在程序中对象就是new出来的有内存空间

2、类和对象的关系

  类和对象的关系： 类是抽象的而对象是具体的， 对象是由类创建的实例（new出来的）
  类的组成（人类）：
    类名： 给某一类事物取个名字： People
    静态的特征称为属性： 姓名，年龄，身高，体重 （定义变量的语法）
    动态的行为称为方法： 吃饭，睡觉，打豆豆 （方法的定义依然满足之前所学）
  类的实现：
    在一个类文件（People）中，定义属性和方法 ​ 对象的实现
    通过类名创建这个类的对象。
    注意：类名不能直接访问 它里面的属性和方法的，必须由类的对象访问
  在类中定义的属性，称为“成员属性” ，在类中定义的方法称为“成员方法”

3、面向对象的特征

  面向对象的三大特征： 封装、继承、多态
  封装： 将类中成员属性 私有化，并提供公有的访问属性的方法。 为了最大程度保护类中属性的隐蔽性（不被其他对象改变。）
  继承： 用于定义类与类的关系的方式 ，一个类可以继承一个类。
  多态： 在继承关系中，一个类的对象可能呈现不同的状态。

4、构造器

  定义： 在创建对象时被自动调用的特殊方法，也称为构造方法。 在一个类中除了包含属性，方法以外，还可以包含 构造器（构造方法）
  每一个类都自带一个无参构造器，也可以在这个类中定义多个构造器，多个构造器之间称为“构造器重载”
  语法：

  访问修饰符 类名([参数列表]){
      
  } 

  例如：

public class Student{
    
     //无参构造器
    public Student （）{
        System.out.println("这是一个无参构造器");
    }
}

  构造器的作用：
    1、用于创建对象自动调用 ，并可以给对象的属性赋初始值
  类与类的关联关系：
    如果在一个类中引用另一个类，那么这两个类属于关联关系。

三、Java的对面对象的特征

1、封装（隐藏）

  对类中的成员属性进行隐藏（私有化），对类中的成员方法公共。
  为了提高类的隐蔽性，对类实现的细节隐藏，提供外部访问的接口即可，提高代码的可扩展性
  生活中的封装： 例如笔记本 的内部结构统一封装了，一般人使用笔记本时不需要了解笔记本的结构，而是直接开机关机使用。
  对代码的封装包括两层意思
   1、对类的成员属性的封装 ：
    将属性私有化（private），提供对属性的访问给属性添加公用的getter和setter方法
   2、对代码的封装：
      为了提高代码的复用性，尽量使用方法加参数传递对代码进行封装，并使该方法公有（public）

public class People {
    private String pname;
    private int age;
    private String sex;
    // 提供 getter 和 setter
    public String getPname()
    return pname;
    }
    public void setPname(String pname){
        this.pname=pname;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        // 对成员属性的隐蔽性 可以防止随意对属性更改
        if(age>100 || age<0){
            System.out.println("赋值的年龄不合法");
            return;
        }
        this.age = age;
    }
    public String getSex(){
        return sex;
    }
    public void setSex(String sex){
        this.sex= sex;
    }
    // 通常为了方便给属性赋值，会提供有参构造
    public People(String pname ,int age,String sex){
        this.pname = pname;
        this.age = age;
        this.sex = sex;
    }
    public People(){

    }
 }

  对于boolean类型的属性，需要使用isXxx返回属性的值。 封装的优点：
  1、良好的封装可以减少类的耦合性（类与类的关联）
  2、对类中封装的代码可以自由修改，而不会影响其他类
  3、最大程度提高类中属性的隐蔽性 和对属性的控制

访问修饰符的权限

  用于修饰类，属性，方法的关键字都称为访问修饰符

1. public：公共的

2. protected：受保护
     可以被自身的类访问，可以被同包下的其他类访问，
   对于不同包的，存在父子关系的子类可以访问

3. 默认的
     可以被自身类访问，可以被同包下的其它类访问

4. private：私有的
     只能被自身类访问

static关键字

  static表示“静态” ，它可以修饰 属性，方法，代码块 ， 在一个类中除了可以定义成员属性、成员方法和构造器以外，还可以定义静态的部分（静态属性，静态方法，静态代码块）
  static 修饰属性：称为 静态属性或类的属性
  static修饰方法：称为静态方法或类的方法
  static修饰的语句块： 称为静态代码块
  static修饰的组件不需要通过对象访问，而是直接通过类名访问，在类一加载时会给static修饰的属性和方法分配内存区，这个内存分布在 静态内存区中。后续所有对象操作的是同一个内存区

2、继承

  一个类A可以继承另一个类B，这里类A就是类B的子类，类A可以继承类比的属性和方法，也可以定义自己的属性和方法

继承的语法

  先定义父类

public  class 父类{
    
}

  再定义子类

public class 子类 extends 父类{
    
}

1. 子类继承父类，子类拥有父类的哪些属性和方法
     可访问： 子类拥有父类的共有的属性和方法， 同包下面的属性和方法，不同包下的受保护的也可以访问
     不可访问： 其中子类不能继承 父类的私有的属性和方法、不同包的默认属性和方法 ，不能继承父类的构造器
2. 子类继承父类，子类如何访问父类的属性和方法
     属性： 子类通过super 关键字访问父类的属性 ，子类通过this关键字访问自己的属性
     方法：子类通过super挂件自方法父类的方法， 子类通过this关键字访问自己的方法
     注意： 这里的this和super可以省略，省略后子类通过“就近原则”访问属性和方法（子类中存在就访问子类的，子类中不存在，就访问父类的。）
     构造器：子类通过super([参数]) 调用父类的构造器， 子类通过this([参数])调用 自己类的其他构造器，其中 super(参数[]) 必须写在子类构造器的第一行
     通过在子类构造器手动调用父类的有参构造器给父类的属性赋值
     注意： 子类构造器中默认调用父类的无参构造器
3. Java中只能是单继承，一个类只能有一个直接父类的父类，可实现多层次继承
     子类 -》 父类 -》 父类的父类
      pupil -> Student-》 People
     创建子类对象时，优先创建父类对象，再创子类对象， 执行顺序 最上层父类的构造器 -》 父类构造器 -》子类构造器。
     扩展问题：当一个类中存在static元素时，它们的执行顺序是如何？
      顺序： 最上层父类的静态块 - 》 父类的静态块-》 子类的静态块- 》最上层 父类的构造块和构造方法-》父类的构造块和构造方法- 》 子类的构造块和构造方法

重写

   子类可以继承父类的方法，但是当父类的方法不能满足子类的需要时，子类可以重写父类的方法
   重写的必要条件：
     1、两个方法名必须相同，且存在不同类中（父子关系的类）
     2、子类重写的父类的方法，其方法的参数和返回值必须完全一样，方法的具体实现可不一样
     3、访问修饰符必须大于或等于父类的修饰符
   注意： 子类的对象 调用父类方法时，如果子类重写了父类的方法，则执行子类的方法，没有重写执行父类的方法。

面试题：

   说一下方法的重写与重载的区别？
  1、重写存在于父子关系中的不同类，重载存在同类中
  2、重写必须满足 方法名相同，且参数相同，返回值相同 ，重载满足方法名相同，参数不同，与返回值无关。
  3、重写的访问修饰符必须 子类大于等于父类， 重载没有要求

3、多态

  为了适应需求的多种变化，类可以呈现多种形态，是代码更加通用
  继Java面向对象中封装，继承之后的第三个特征
  生活中的多态: 同一个行为，例如跑，人是两条腿跑，动物是四条腿或两条腿跑，飞的行为不同是事物飞的方式也不同，飞机飞，小鸟飞，无人机飞都不一样，同一种行为对于不同的事物呈现的不同形态就是多态的表现。

定义：

  同一种行为，具有多个不同的表现形式

实现多态的前提：

1. 基于继承关系或是基于实现关系的
2. 子类或实现类必须对方法进行重写（没有重写的方法 不具有多态行为）
3. 父类的引用指向子类对象（ 接口的引用指向实现类的对象）

多态的对象转型：

1. 子类对象转父类对象时，称为向上转型是默认转换，自动转型
2. 引用转成子类对象，称为向下转型，向下转型需要强转 ， 为了避免转换错误，需要先判断数据类型是否匹配
     instanceof : 判断该对象是否属于 这个类型
     为什么需要做类型换行呢？ 有时候我们需要调用子类特用的方法时必须用子类的引用。所有多态对象下父类应用需要强转。
     为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验。

在多态环境型，方法和属性的条用规则：

  属性: 当子类和父类中存在相同属性时 ，以 对象的左边引用类型为依据，所谓“看左边”
  方法： 以当前new出来的对象为依据，如果方法重写了，就调用子类方法，如果方法没有重写 调用父类方法
  静态方法： 无论方法是否有重写， 都已对象左边的引用类型为依据。