java封装、继承、多态

一、封装

1、定义：设计一个类的时候，用private修饰所有的属性并对外暴露相应的setter、getter方法，对私有的属性进行设置和获取的操作。
2、关键字：private
3、用private修饰的属性只能在本类中使用，使用public修饰的属性可以在任何地方都能够访问。

二、继承

1、定义：将多个相关的类（子类）中，共有的特征和行为抽取到一个共通的类（父类）中，然后让这些类复用共通类中可见的属性和方法。
2、关键字：extends
3、继承的目的：提高代码的复用性。
4、注意：若两个有继承关系的类之间没有extends关键字指明，就是“隐性继承“，在java中只有一个“隐性继承“，就是Object
5、子类实例化的过程：优先创建父类对象的实例，在创建子类对象的实例

注意：

1、构建字类对象时，若用无参构造方法，默认先调用父类的无参构造方法

2、在子类的构造方法中，若没有指明调用父类哪个构造方法，则默认调用父类的无参构造方法，在调用子类相应的构造方法。

3、若父类中没有无参构造方法，在子类中应显式的调用父类中有参的构造方法（类中如果重写构造方法，那么默认存在无参构造方法，若重写，则默认的无参构造方法不存在）

4、java中只存在单继承，即一个类有且只能继承一个直接父类（是直接哈，例如：B继承A，C继承B，那么可以说，C间接继承A）

三、多态

1、定义：
- 多态性：父类的引用指向字类的实例
- 多态：多种状态，就是对象的多种状态，既可以说是父类的类型的实例，也可以说是具体子类类型的实例。
2、关键字：instanceof

对象 instanceof 类型
＝＝》指定的对象是否属于instanceof关键字之后所制定类型的实例，若是，返回true，否则false

if(pet instanceof PetDog){
    PetDog dog = (PetDog)pet; 
}

3、举个例子说明一下

//这是一个展示宠物的方法,参数是Pet(父类),这样设计的目的,该方法可以接受任何子类对象
public void showPet(Pet pet){
//方法体
}

//当我要调用这个方法的时候
Dog dog = new Dog();//Dog类是Pet的子类
showPet(dog);

4、方法的调用

//Person是父类，SubPerson是子类
Person p = new Person();
p.sleep();//调用的是父类中的sleep方法

SubPerson sp = new SubPerson();
sp.sleep();//调用的是字类中sleep方法

Person p = new SubPerson();
p.sleep();//调用的是字类中sleep方法

5、对象的向上转型：有继承关系的两个类之间，父类的引用指向子类的实例（相兼容的基本数据类型之间自动转型）

Pet pet = new PetDog();

6、对象的向下转型：在有继承关系的两个类之间，父类的引用要调用子类对象特有的方法时，需要强制将父类对象转换为子类类型（强制转换）

Pet pet = new PetDog();
PetDog pdog = (PetDog)pet;
pdog.特有方法();

注意一定要看

class BaseClassP{
public int book = 6;
public void base(){
        System.out.println("父类的普通方法");
    }
public void test(){
        System.out.println("父类被覆盖的方法");
    }
}


public class SubClass extends BaseClass{
public String book = "哈哈";
public void test(){
        System.out.println("子类覆盖父类中的方法");
    }
public void sub(){
        System.out.println("子类的普通方法");
    }

public static void main(String[] args){
//编译时类型和运行时类型完全一样，所以不存在多态
        BaseClass bc = new BaseClass();
//输出6
        System.out.println(bc.book);
//下面两个方法调用BaseClass的方法
        bc.base();
        bc.test();
//编译时类型和运行时类型完全一样，所以不存在多态
        SubClass sc = new SubClass();
//输出哈哈
        System.out.println(sc.book);
//调用的是父类的方法，从父类那继承来的
        sc.base();
//调用的是自己的方法
        sc.test();
//编译时类型和运行时类型不同，所以存在多态
        BaseClass p = new SubClass();
//输出6，访问的是父类的属性
//**无论编译和运行，都参考左边**
        System.out.println(p.book);
//调用父类的方法，继承来的
        p.base();
//调用的是子类中的方法，被覆盖了
        p.test();
//编译出错，应该是SubClass s = （SubClass）p;s.sub();
//**编译看左边，运行看右边**(左边的BaseClass类型中无sub方法，所以报错)
        p.sub();
    }
}

简单总结就是：

成员方法：编译看左边，运行看右边

成员变量：无论编译和运行，都参考左边(引用型变量所属的类)。

秒客网

java封装、继承、多态

相关文章