封装+继承+多态笔记及总结

1. 封装

定义

封装就是隐藏对象的属性和实现细节，仅提供公共访问方式来让外界访问

访问修饰符

分为public,protected,default,private这四类

以下是访问修饰符的权限范围表：

其中，private修饰的成员变量只能在相应的类中使用，如果想要在外界访问它，只能提供公开访问的方法让外界可以去访问它，我们可以给私有属性提供get和set方法(alt+ins即可自动生成相关属性的get和set方法)，这样外界就可以通过调用get和set方法获取到私有属性的值和设置私有属性的值

例：

//类代码
package com.quan.packaging;
​
public class Packaging {
    private int money;
    //有参构造，初始化money
    public Packaging(int money){
        this.money=money;
    }
    //getMoney获取私有属性money的值，setMoney设置私有属性的值
    public int getMoney() {
        return this.money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
}
//----------------------------------------------------------------------------------------------------------
//main代码
package com.quan.packaging;
​
public class Application {
    public static void main(String[] args) {
        Packaging packaging = new Packaging(1000);
        packaging.setMoney(100);
        System.out.println(packaging.getMoney());
    }
}

目的

为了不直接被外部使用

口诀

属性私有，get/set

---

2. 继承（单继承）

定义

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为，子类拥有父类所有的方法，是类与类之间的一种关系

语法

class 子类名 extends 父类名

子类获取父类属性和方法的使用

在主类中获取

public，protected，default属性和方法：在主类使用可直接在主类new一个子类对象，然后通过子类名+父类属性/方法调用

例：

//父类
package com.quan.use;
​
public class B {
    public String name;
​
    public B() {
        this.name = "张三";
    }
}
//-------------------------------------------------------------------------------------------------------
//子类
package com.quan.use;
​
public class A extends B{
}
//----------------------------------------------------------------------------------------------------------
//主类
package com.quan.use;
​
public class Application {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.name);
    }
}

private属性和方法：子类无法继承，但可通过封装里的方法获取到private的值和设置private的值

例：

//子类
package com.quan.use;
​
public class B {
    private String name;
​
    public B() {
        this.name = "张三";
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
}
//----------------------------------------------------------------------------------------------------------
//父类
package com.quan.use;
​
public class A extends B{
​
}
//----------------------------------------------------------------------------------------------------------
//主类
package com.quan.use;
​
public class Application {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.getName());
        a.setName("李四");
        System.out.println(a.getName());
    }
}

在子类中获取

可通过super关键字直接获取，super+父类属性/方法名即可获取相应的父类属性/方法名

例：

//父类
ackage com.quan.use;
​
public class B {
    private String name;
​
    public B() {
        this.name = "张三";
    }
​
    public String getName() {
        return name;
    }
}
//--------------------------------------------------------------------------------------------------------
//子类
package com.quan.use;
​
public class A extends B{
    public void get(){
        System.out.println(super.getName());
    }
}
//--------------------------------------------------------------------------------------------------------
//主类
package com.quan.use;
​
public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.get();
    }
}

super关键字（调用父类属性/方法）

注意点

子类中super调用父类的构造方法，必须在子类构造方法的第一个

super必须只能出现在子类的方法或者构造函数中

super和this不能同时调用构造方法

对比（this）

代表对象不同:

this：本身调用者这个对象

super：代表父类对象的引用

前提：

this：没有继承也可以使用

super：只能在继承条件下才可以使用

构造方法：

this：本类的构造

super：父类的构造

//子类
package com.quan.use;
​
public class B {
    public String name;
​
    public B() {
        this.name = "张三";
    }
}
//-------------------------------------------------------------------------------------------------------
//父类
package com.quan.use;
​
public class A extends B{
    public String name;
​
    public A() {
        this.name = "李四";
    }
    public void get(){
        System.out.println(this.name);
        System.out.println(super.name);
    }
}
//--------------------------------------------------------------------------------------------------------
//主类
package com.quan.use;
​
public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.get();
    }
}

重写（单指方法，和属性无关）

在主类中new两个相同的子类对象，并且子类和父类有相同的方法，但返回的类型设为一个父类型和一个子类型，静态方法和非静态方法展现出来的效果不同

静态方法

方法的调用只和左边定义的数据类型有关

//父类
package com.quan.rewrite;
​
public class B {
    public String name;
    public static void print(){
        System.out.println("BBB");
    }
}
//-------------------------------------------------------------------------------------------------------
//子类
package com.quan.rewrite;
​
public class A extends B{
    public String name;
    public static void print() {
        System.out.println("AAA");
    }
}
//--------------------------------------------------------------------------------------------------------
//主类
package com.quan.rewrite;
​
public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.print();
        B b = new A();
        b.print();
    }
}

非静态方法

• 子类型 展现子类方法调用的相应结果

• 父类型 重写为子类的方法

//子类
package com.quan.rewrite;
​
public class A extends B{
    public String name;
    public A() {
        //子类无参构造器隐藏代码：调用了父类的无参构造
        //调用父类的构造器只能在子类构造器的第一行
        super("hello");
        System.out.println("A无参构造");
    }
​
    @Override
    public void print() {
        System.out.println("AAA");
    }
}
//-------------------------------------------------------------------------------------------------------
//父类
package com.quan.rewrite;
​
public class B {
    public String name;
    public B(String name) {
        this.name=name;
        System.out.println("B无参构造");
    }
​
    public void print(){
        System.out.println("BBB");
    }
}
//--------------------------------------------------------------------------------------------------------
//主类
package com.quan.rewrite;
​
public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.print();
        B b = new A();
        b.print();
    }
}

父类型（向上转型）

可指向子类，但不可以调用子类独有的方法，若重写，则调用重写的方法，即为子类的该方法

子类型

可调用自己的方法（this）或者父类的方法（super）

动态绑定

所谓动态绑定就是使用父类引用子类对象然后（向上转型）调用父类和子类相同的方法在子类中重写了父类的方法

快捷键

alt+ins 点击override

条件

1. 方法名必须相同

2. 参数列表必须相同

3. 修饰符：范围可以扩大但不能缩小； public>protected>default>private

4. 抛出的异常：范围，可以被缩小，但不能扩大 ClassNotFoundException-->Expection(大)

意义

父类的功能，子类不一定需要，或者不一定满足！

注：对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！

目的

防止重复代码多次书写

---

3. 多态（单指方法，和属性无）

定义

同一方法可以根据发送对象的不同而采取多种不同的行为方式

依据

一个对象的实际类型是确定的，但可以指向对象的引用的类型很多（父类，有关系的类）

存在的条件

• 有继承关系

• 子类重写父类方法

• 父类引用指向子类对象

Father father = new Son();
//具体可参考继承-重写-非静态方法中的代码
B b = new A();

注：有些方法不可以重写，无法实现多态

1. static 方法，属于类，它不属于实例

2. final 常量

3. private 方法

instanceof

语法

某类对象引用+instanceof+某个类

返回类型

boolean类型

作用

测试左边的对象是否是右边类或者该类的子类 创建的实例对象

在强制转换前使用instanceof运算符判断是否可以成功转换

package com.quan.instance;
​
public class Test {
    public static void main(String[] args) {
        //Object->B->A
        Object object = new A();
        A a = new A();
        B b = new A();
        B c = new B();
        System.out.println(object instanceof A);
        System.out.println(object instanceof B);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof String);
        System.out.println("------------------------------------------------------------------");
        System.out.println(a instanceof A);
        System.out.println(a instanceof B);
        System.out.println(a instanceof Object);
        System.out.println("-----------------------------------------------------------------");
        System.out.println(b instanceof A);
        System.out.println(b instanceof B);
        System.out.println(b instanceof Object);
        System.out.println("------------------------------------------------------------------");
        System.out.println(c instanceof A);
        System.out.println(c instanceof B);
        System.out.println(c instanceof Object);
    }
}

---

4.抽象类

定义

被abstract修饰，包含抽象方法的类（也可以不含抽象方法，建议抽象类和抽象方法同时使用），不能直接实例化，只能被继承之后通过子类调用父类的构造方法使用

包含

普通方法

抽象方法：只有方法的声明，所以调用该抽象类，需重写所有抽象方法，若不重写，则需声明该类也为抽象类

目的

为了继承之后重写发生动态绑定，减少重复代码，提高开发效率

//抽象类
package com.quan.abstra;
​
public abstract class Action {
    //抽象方法只要写方法的声明
    //抽象方法必须在抽象类中
    public abstract void get();
    //可以写普通函数
    public void set(){
        System.out.println("你好");
    }
}
//-----------------------------------------------------------------------------------------------------
//继承抽象类的类
package com.quan.abstra;
​
public class A extends Action{
    public void get(){
​
    }
}

注：由抽象方法的类一定要声明为抽象类

抽象类不存在构造器

---

5.接口（interface）

作用

1. 约束

2. 定义一些方法，让不同的人实现

默认方法

public abstract

所有常量

public static final

注：接口不能实例化，接口中没有构造方法

implements可以实现多个接口

必须要重写接口中的方法

//接口UserService
package com.quan.port;
​
public interface UserService {
    void add(String name);
    void delete(String name);
    void updata(String name);
    void query(String name);
}
//----------------------------------------------------------------------------------------------------------
//接口TimeService
package com.quan.port;
​
public interface TimeService {
}
//----------------------------------------------------------------------------------------------------------
//实现接口
package com.quan.port;
//
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {
        
    }
​
    @Override
    public void delete(String name) {
        
    }
​
    @Override
    public void updata(String name) {
        
    }
​
    @Override
    public void query(String name) {
        
    }
}

注：所有的类，都默认直接或者间接继承object类

大部分笔记来自狂神说，少部分是根据自己不理解的地方补充的，来自csdn上的博客们