封装、继承、多态

封装

1.封装？？

封装就是把对象的属性和操作（方法）结合起来，通过访问修饰符限制权限问题，来进行信息的隐藏、外部人员不能随意访问

当一个类的数据封装起来之后、调用这个类的人员就不用关心代码复杂程度、直接入口访问就好

封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

2.封装做法

class Peoples{
    private int age; //用private修饰成员变量
    public void setAge(int age){ //设置方法为变量赋值
        if(age <0||age >130){
            System .out .println("年龄无效") ;
        }this .age=age ;
    }
    public int getAge(){ //设置方法获取赋值
        return age ;
    }
    public static void main(String[] args) {
        Peoples peoples =new Peoples() ; //创建对象
        peoples .setAge(97) ; //调用方法
        System .out .println(peoples .getAge() ) ;
    }
}

1. 在类中使用private私有化成员变量。
   2、创建set方法，使其他类可以通过此方法为变量赋值。
   3、set方法里设置限定条件。
   4、给出get方法，使其他类能够输出合理数据。

3.封装好处

一、数据的安全性提高了用private把类的细节与外界隔离起来，从而实现数据项和方法的隐藏，而要访问这些数据项和方法唯一的途径就是通过类本身

二、是通过隐藏隔离，只允许外部对类做有限的访问，开发者可以自由的改变类的内部实现，而无需修改使用该类的那些程序。只要那些在类外部就能被调用的方法保持其外部特征不变，内部代码就可以自由改变，各取所需，利于分工。

三、提高了代码的重用性，封装成工具类以后能够减少很多繁琐的步骤。

继承

继承的定义

class 子类 extends 父类{}
继承是一种java的机制，子类可以继承父类的所有属性和方法；当子类继承父类时。可以重复使用父类中的属性和方法，也可以添加新的属性和方法，
1.新类被称为子类，孩子类，派生类
2.已存在的类被称为超类，父类，基类
（子类比超类拥有更丰富的功能，因此在设计类的时候，应该将通用的方法放在超类，将具有特殊用途的方法放在子类中。子类的每个对象也是超类的对象）

关键字super：
使用super调用，父类要有构造器
作用： 调用超类的方法 调用超类的构造器

private-对本类可见
protect-对本包和所有子类可见
public-对所有类可见
包含一个或多个抽象方法的类本身必须被声明为抽象的，抽象方法的具体实现在子类中。abstract
抽象类不能被实例化，类即使不含抽象方法，也可以将类声明为抽象类。
父类

public class Animal {
    protected int age;  //定义一个Animal类 父类
    protected String name;

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

    public void  eat(int age) {
        if (age < 15) {
            System .out .println("吃的少") ;
        } else  {
            System .out .println("吃的多") ;

        }
    }


}

子类 增加颜色的属性

public class Dog extends Animal { //定义一个Dog类 子类 派生类
    private String color;
    public Dog(String name,int age,String Color){ 
    super(name,age);
    this.color=coloe;
    }
      @Override
       public void  eat(int age) {
        if(age<3){
            System .out .println("这个动物年龄小,吃的少") ;
       }
     }

方法重写与方法重载

子类可以调用父类的方法，但父类不能调用子类的方法
static，final，private不能被重写。

方法重载 :同一个类中，方法名相同，参数列表不同（类型，个数）
重载对返回类型没有要求，可以相同可以不同，但不能通过返回类型判断是否重载.

class A{
    public void win(){
        System .out .println("任何A都可以获胜") ;
    }
    public void  win(int age){
        System .out .println("任何A都可以获胜") ;
    }
    public void  win(double  num){
        System .out .println("任何A都可以获胜") ;
    }
}

方法重写：不同类
1.在父子类中，子类重写 父类方法
2.函数名，参数列表相同
3.访问限定符 子类>=父类权限 public>protected>private
实现原理：对父类进行 地址覆盖

class A{
   public void win(){
       System .out .println("任何A都可以获胜" ) ;
   }
}
class B extends A{
    @Override
    public void win() {
        System .out .println("只有B可以获胜" ) ;
    }
    public static void main(String[] args) {
        B b =new B() ;
        b.win() ;


    }
}

可以看到子类和父类当中都有win方法，而我们实际调用的却是子类自己的win方法，这就是方法的覆盖，子类通过重写和父类一样的方法实现方法的覆盖。
区别：
方法重载和重写都是实现多态的方式，前者实现的是编译期的多态性，后者实现的是运行时的多态性。重载发生在一个类中，重写发生在父类和子类之间，要求子类被重写方法与父类被重写方法的参数列表相同，有兼容的返回类型，比父类重写方法更好的访问，不能比父类被重写方法更多的异常。重载对于返回类型没有要求。

继承的层次

继承并不仅限于一个层次，由一个公共超类派生出来的所有类的集合被称为继承层次。
在继承层次中，从某个特定的类到其祖先的路径被称为该类的继承链。
一个祖先链可以有多个子孙链接。eg：Animal派生Dog和 Cat，他们之间可能没有任何关系

继承：Java继承只能单继承不能多继承

•      class A extends B,C{ } //error
  

若同时继承B.C，如果他们有同名的属性或方法，A调用会产生歧义。
1.菱形继承（单继承，多级继承，分层继承）
a.编译期多态（静态绑定）（方法重载）
b.运行期多态 （动态绑定）
（1）继承
（2）方法重写
（3 ）向上造型 基类的引用
注意
当用final修饰一个类时，表明这个类不能被继承。

多态

1.什么是多态？

多态是一个行为具有多种不同表现形式或形态的能力，不同类的的对象可以对同一消息做出不同反应
父类可以根据子类的不同，而使得同一个方法产生不同的结果

动态绑定:在运行时能够自动的选择调用哪个方法的现象

多态的前提

必须存在继承或者实现关系

多态成员特点

多态成员变量 ：编译运行看左边

A a=new B（）；
    System .out .println(a.syx) ; //打印的是A中的属性

多态成员方法

A a=new B（）；
 a.win（） ; //拿到的是B中的方法

2.向上造型

Object 所有类的父类

 Animal animal =new Dog() ;
   animal .eat(10) ;
    ((Dog) animal) .f() ;```

引用出来的是父类Animal 的方法接口，若子类重写了父类的方法则实现的是子类Dog的方法
 若子类无这个方法实现的是父类的方法

people a=new Animal（）；//error 向下造型

people a=（people）new Animal（）//

左边是什么类型就执行这个类型的方法，若父类子类都有这个方法，则执行子类中重写的方法。

          

#### 3.发生多态的条件
1.继承
2.方法重写
3.向上造型（基类引用 引用 派生类对象）。。
####  父类能调用子类的方法吗
可以
子类传递到父类的有参构造中，然后调用
 父类调用子类的静态方法。
 使用反射的方式调用
 

class A extends B{
public void fun(){
}
}
class B{
Class cl=Class.forName(“A ”) ； 传的是子类的路径
A a=(A)cl.newInstance();
a.fun（）；
}

**new和 newInstance 都是为了创建一个对象，区别是什么？**
区别是：new 是一个关键字 而 newInstance是一个方法
 局限性：new 创建的对象可以调用任何方法、 而newInstance只能调用无参构造函数
            从JVM虚拟机来看，newInstance的使用让JVM加载了该类、并且这个类已经连接了、
            newInstance()实际上是把new这个方式分解为两步，即首先调用Class加载方法加载某个类，然后实例化
           使用关键字new创建一个类的时候，这个类可以没有被加载

Class.forName(“”)返回的是类。
Class.forName(“”).newInstance()返回的是object 。