Java面向对象(三):封装,继承与多态

面向对象三大特征:封装,继承,多态

1.封装 ->封装的核心思想是权限控制,目的是信息保护
当类和类内部的成员被定义好后,基于安全性考虑可能并不希望把所有成员都暴露给外部调用,于是通过权限修饰符控制使得外部无法直接使用部分成员,这个过程就是封装。
public class Oop {

    //私有属性,仅当前类可以使用
    private int iPR = 0;

    //setter方法
    public void setiPR(int iPR){
        //赋值之前可以对入参进行控制
        if(iPR>10) iPR=add(iPR);
        
        this.iPR=iPR;
    };

    //getter方法
    public int getiPR(){
        return iPR;
    }
    
    //私有方法,仅当前类可以使用
    private int add(int i){
        return i+1;
    }
}
权限修饰符共有public,protected,默认,private四种。将在继承之后统一介绍
权限修饰符也可以修饰外部类,只能使用public和默认
public外部类:该外部类若想被包外的其他类中所访问,可以通过import关键字进行导包。
默认外部类:该外部类无法存在于包外的其他类中，即使导包也没用。

2.继承 ->继承的核心思想是分类(is-a),目的时代码复用
当定义的类越来越多后,为了便于管理要对定义的class进行分类。
同时,为了提高代码复用性,将同一类共同的代码抽出来让所有这一类的class都能使用。
共同使用的代码便重新定义一个class,就是父类。
而其余的class要使用extends关键字和这个公共class产生联系,就是继承。

public class Animal {
    //父类-动物
}

class Cat extends Animal{
    //子类-猫
}

class Dog extends Animal{
    //子类-狗
}

1).Java使用的是单继承,即一个类只能有一个父类,Java中所有类都继承自Object类。
2).final关键字可以修饰类,final修饰的类不可以被继承
3).由于Java的封装性,所以即使是继承关系也不能使用父类所有的成员
    四种权限修饰符
    private:私有的,本类使用
    defalut:默认的,可以省略不写。同包类使用。
    protected:受保护的,同包类+不同包子类使用
    public:公共的,项目中所有类

package com.springlight;

public class Animal {
    //private只能本类内使用
    private void m1(){

    };

    //默认
    void m2(){

    };;

    //受保护的
    protected void m3(){

    };;
    //公共的
    public void m4(){

    };;
}

class Cat extends Animal{

}

class Dog extends Animal{

}

class Bus{
    //同包类
    public void test(){
        Animal animal = new Animal();
        //private修饰的方法不可以使用
        //animal.m1();
        animal.m2();
        animal.m3();
        animal.m4();
    }
}

package com.springliant2;

import com.springlight.*;

public class Pig extends Animal {
    //不同包子类
    public void test(){
        Animal animal1 = new Animal();
        Pig pig = new Pig();
        //private修饰的方法不可以使用
        animal1.m1();
        pig.m1();
        //不同包时,默认修饰符修饰的的方法都不可用
        a