封装、继承、多态、接口

时间：2020-12-04 14:40:16 收藏：0 阅读：24

封装

改露的露，改藏的藏

我们程序设计要追求"高内聚，低耦合"，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉，低耦合就是仅暴露少量的方法给外部使用

封装就是数据的隐藏

通常应禁止直接访问一个对象数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

属性私有，get/set

set方法是为成员变量赋值
get方法是获取成员变量的值

代码演示

//学生类
public class Student {
    //成员变量
    //姓名
    private String name;
    //年龄
    private int age;

    //set get
    //alt + insert
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //成员方法
    public void study(){
        System.out.println("键盘敲烂 月薪过万");
    }

    public void eat(){
        System.out.println("学生要吃有营养的饭");
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //给成员变量赋值
        s.setName("小明");
        s.setAge(25);

        //获取成员变量的值
        System.out.println(s.getName() + "  " + s.getAge());
    }
}

封装作用

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护性增加

继承

继承的本质就是对某一批类的抽象，从而实现对现实世界美好的建模

extends的意思是"拓展"。子类是父类的拓展

Java中类只有单继承，没有多继承

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等

继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示

子类和父类之间，从意义上讲应该是具有"is a"的关系

在Java中所有的类都默认直接或者间接继承Object类

//人类（父类）
public class Person {
    //成员变量
    String name;
    int age;

    //成员方法
    public void eat(){
        System.out.println("好好吃饭 天天长大");
    }

    public void sleep(){
        System.out.println("好好睡觉");
    }
}

//学生类（子类）
public class Student extends Person{
    //自动继承父类的成员
}

public class Test {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();

        //使用成员变量
        s.name = "小明";
        s.age = 28;

        //使用成员方法
        s.eat();
        s.sleep();
    }
}

this和super关键字

变量和方法的访问规则(重名情况):
- this:优先访问本类的成员变量和成员方法
- super:优先访问父类的成员变量和成员方法
this和super访问构造方法：
- 写法：
  - super()用来访问父类的构造方法
  - this()用来访问本类的其他构造方法
- 注意事项：
  - this()和super()都必须放在构造方法的第一行，所以在一个构造方法中只能写一个this()或super()
- 常规写法：
  - 子类的空参调用父类的空参
  - 子类的有参调用父类的有参
代码演示

成员变量和成员方法：---------------------
public class Person {
    //成员变量
    String name = "王健林";
    
    //成员方法
     public void eat(){
        System.out.println("父类的吃饭方法");
    }
}

public class Student extends Person {
    //成员变量
    String name = "王思聪";

    //方法
    public void show(){
        //局部变量
        String name = "王可可";

        System.out.println(name);       //"王可可"
        System.out.println(this.name);  //"王思聪"
        System.out.println(super.name); //"王健林"
        
        //调用方法
        eat();      //就近原则
        this.eat(); //和上面写法是一样的
        super.eat();//访问父类的成员方法
    }
}


构造方法：-------------------------------
//父类
public class Person {
    String name;
    int age;

    //构造方法
    public Person() {
        System.out.println("父类空");
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("父类有");
    }
}
//子类
public class Student extends Person {
    //构造方法
    //空参构造
    public Student() {
        //访问父类的空参构造
        //super();
        System.out.println("子类空");
    }

    //有参构造
    public Student(String name, int age) {
        //访问父类的有参构造
        super(name, age);
        System.out.println("子类有");
    }
}

多态

即同一个方法可以根据发送对象的不同而采用不同的行为方式

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

多态的前提

要有继承或者是实现
要有方法的重写
要用父类引用指向子类对象

注意：多态是方法的多态，属性没有多态性

多态的成员访问规则

成员变量
- 编译看左边(父类)，运行看左边(父类)
成员方法
- 编译看左边(父类)，运行看右边(子类)
代码演示

public class Person {

    String name = "王健林";

    public void eat(){
        System.out.println("王健林吃米其林");
    }
}

public class Student extends Person {

    String name = "王思聪";

    public void eat(){
        System.out.println("王思聪吃热狗");
    }
}

public class Test {
    public static void main(String[] args) {
        //一个学生是一个人
        Person p = new Student();

        //访问变量
        //编译看左边(父类)，运行看左边(父类)
        System.out.println(p.name);

        //访问方法
        //编译看左边(父类)，运行看右边(子类)
        p.eat();

    }
}

多态的好处和弊端

弊端
- 不能调用子类的特有方法，只能调用父类中定义的共性方法
好处
- 提高了代码的扩展性
- 示例代码

public class Test {
    public static void main(String[] args) {
        //创建对象
        Sheep s = new Sheep();
        method(s);

        Dog d = new Dog();
        method(d);

        Cat c = new Cat();
        method(c);
    }

    //使用多态
    //提高了代码的扩展性
    public static void method(Animal a){      //相当于： Animal a = new Sheep();
        System.out.println("有请开始叫：");    //相当于： Animal a = new Dog();
        a.jiao();                            //相当于： Animal a = new Cat());
    }


    /*
    不使用多态
    //定义方法
    public static void method(Sheep s){
        System.out.println("有请开始叫：");
        s.jiao();
    }

    //定义方法
    public static void method(Dog d){
        System.out.println("有请开始叫：");
        d.jiao();
    }

    //定义方法
    public static void method(Cat c){
        System.out.println("有请开始叫：");
        c.jiao();
    }
    */
}

多态的转型

向上转型
- 把子类类型转成父类类型
```
Person p = new Student();
```
向下转型
- 把父类类型转成子类类型
```
Student ss =(Student) p;
```
类型转化异常
- ClassCastException：类型转换异常
- 做了不正确的向下转型。

接口

接口的概念

概念:
- 在生活中接口就是规范，在java中接口是一种数据类型，他的作用也相当于是规范。
格式：

public interface 接口名{
    
}

接口的实现

接口和类使用是非常相似的，类可以被继承的，而接口可以被实现。

格式：

public class 类名 implements 接口{
    
}

//接口被实现,实现类也能够拥有接口的成员

接口的成员

接口中的方法：
- 抽象方法：

//抽象方法
public abstract void method();

- 静态方法：

//静态方法(直接用接口名调用)
public static void method2(){
    System.out.println("静态方法");
}

- 默认方法：

//默认方法(让子类直接使用)
public default void method3(){
    System.out.println("默认方法");
}

- 私有方法：

//私有方法(如果本类中有重复的代码,就可以写在私有方法中)
private void method4(){
    System.out.println("私有方法");
}

接口中的变量：
- 接口中的变量都叫常量。

//定义变量
int a = 10;

接口的注意事项

我们习惯把实现和被实现的关系也叫做是子类和父类的关系
接口中的成员变量是常量，默认有三个修饰符 public static final
接口的普通方法都是抽象方法，默认有两个修饰符 public abstract
接口中不能有构造方法，接口也不能被创建对象
接口的实现类必须重写接口的所有抽象方法，或者实现类是一个抽象类

类和类的关系：

类可以继承类，java中只支持单继承。(一个类只能有一个父类,一个类只能有一个亲爹)

类和接口的关系：

类可以实现接口，java中支持多实现。(一个类可以实现多个接口，一个类可以有多个干爹)

接口和接口的关系：

接口和接口是继承关系，java中的接口是多继承。(平时写代码不会遇到)

结论：

在开发中遇到最常见/最复杂的写法：
一个类在继承一个父类的情况下再实现多个接口
QQQ这个类继承了CCC类还实现了AAA和BBB两个接口

public class QQQ extends CCC implements AAA,BBB{

}

原文：https://www.cnblogs.com/SunJunchen/p/14084950.html

封装、继承、多态 、接口

封装