Java之Java基础十一（面向对象）

• 面向过程：按照步骤依次执行程序
• 面向对象：首先抽离出参与的对象，然后调用对象相关方法完成执行程序需求（高内聚，低耦合）
• 面向对象三大特征：封装，继承，多态
• 类是对象的抽象模板， 对象是类的具体实例

一、构造方法

•  构造方法【也叫构造器】无返回值类型，是一种特殊的方法
• 方法名与类名必须一致
• 作用：用于初始化对象
• 在对象创建时调用【最简调用：new Test();】
• 一个类中默认有一个无参构造方法，一但自行书写了任意构造方法，会覆盖掉原来的无参构造方法 【若书写的为有参的则：new Test();报错】，若需使用无参构造方法，则需自行书写【方法重载】
• 构造方法支持方法重载
• 构造方法方便初始化对象时赋值（有参构造方法）

二、封装 

• 关键字：private
• 快速生成访问器与修改器：ALT+SHIFT+S（source[源码]）->生成getter和setter

三、继承

• java面向对象编程的基石，子类继承父类的特征和行为，实质为提炼共有特征和行为的父类，达到高 内聚低耦合的作用，便于复用以及维护

• 子类称派生类，父类称超类

• 继承层次：java只支持单继承，即直接父类只能有一个

• 方法重写【重写发生在运行阶段】 

子类返回值的范围要小于等于父类【例如引用类型】

子类访问权限修饰符要大于等于父类【public>protected>private】

特殊：子类不能继承父类的private方法，即不能重写父类的private方法 

//使用场景：继承了父类的子类中的方法覆盖了父类中的方法（方法签名相同）
//父类
public class Person {
    public void run()  {
        System.out.println("runing");
    }
 }
 //子类
public class Student extends Person{
    public void eat() {
        System.out.println("eating");
    }
    public void run() {   //方法重写(子类覆盖子类,就近原则,子类与父类方法签名一致)
        System.out.println("runing4");
    }
    public void run(String str) {   //方法重载(方法名一致，方法签名不一致)，发生在编译阶段
        System.out.println("runing4");
    }
 }

• 继承时执行顺序

类加载>普通变量及语句加载>构造方法加载

父加载>子加载 

 public class test extends Base{
    static {
        System.out.println("子类初始化");
    }
    public test(){
        System.out.println("子类构造方法");
    }
    public static void main(String[] args) {
        new test();
    }
 }
 class Base{
    static {
        System.out.println("父类初始化");
    }
    public Base(){
        System.out.println("父类构造方法");
    }
 }
 //运行结果            
父类初始化
子类初始化
父类构造方法
子类构造方法 

package jicheng;
 public class test{
    public static void main(String[] args) {    
        new MyClass();
    }
    static {
        System.out.println("test初始化"); //1
    }
    public test(){
        System.out.println("test构造方法");   //5
    }
    Base base=new Base("123");      //34
 }
 class Base{
    static {
        System.out.println("base初始化");   
    }
    public Base(String str){
        System.out.println("base构造方法"+str);   
    }
 }
 class MyClass extends test{
    Base base=new Base("456");   //6
    static {
        System.out.println("myclass初始化");  //2
    }
    public MyClass(){
        System.out.println("myclass构造方法");   //7
    }
 }
 //结果
test初始化
myclass初始化
base初始化
base构造方法123
 test构造方法
base构造方法456
 myclass构造方法

四、多态

• 同一种行为具有的不同种表现形式或者形态的能力叫多态，用来实现动态联编
• 实质是程序的最终状态是在执行过程中决定而不是在编译期间决定
• 形成多态的必要条件

1. 子类必须继承父类，即必须有继承
2. 必须有重写
3. 父类引用要指向子类对象

• 方法参数也可以使用多态
• 父类引用要指向子类对象不一定是父子，是包含关系即可
• 存在方法重载，并且重载的方法里参数为包含关系时遵循就近原则（先找自己，没有的话有父类找父 类，还没有找父类的父类，以此类推） 

//祖先
public class Livething {
    public void eat() {
        System.out.println("live");
    }
    public void run() {
        System.out.println("live");
    }
 }
 //父类继承并重写
public class Animal extends Livething{
    public void eat() {
        System.out.println("进食");
    }
    public void run() {
        System.out.println("运动");
    }
 }
 //子类继承并重写
public class Cat extends Animal {
    public void eat() {
        System.out.println("优雅的进食");
    }
    public void run() {
        System.out.println("优雅的运动");
    }
 }
 //多态
public class Test {
    public static void main(String[] args) {
        Animal a=new Animal();  //正常定义
        a.eat();
        a.run();
        System.out.println("-------------");
        //父类引用要指向子类对象
        Animal b=new Cat();     //多态,自动类型转换(小转大：cat->animal)
        b.eat();
        b.run();
        //支持父类[指向子类对象的父类]转成子类,其他不支持
        if(b instanceof Cat) {
            Cat b_Cat=(Cat)b;
            b_Cat.sleep();
        }
        System.out.println("-------------");
        eating(a);
        eating(b);
    }
    //存在方法重载时遵循就近原则（先找自己，没有的话有父类找父类，还没有找父类的父类，以此类
推）
    //方法参数也可以使用多态
    public static void eating(Animal animal) {
        animal.eat();
    }
    public static void eating(Livething animal) {
        animal. Eat();
    }
 }