JavaSE中级之Java面向对象二

Java面向对象二

三大特性

封装

  • 封装的好处是能提高代码的安全性

  • 把该隐藏的隐藏，该暴露的暴露，这就是封装的设计思想

  • 将属性用private修饰私有化，提供public修饰的方法

  • 外界可以访问属性但是不能随意访问，因为我们可以加入限制条件

  • 实际开发中一般会写成setter，getter方法

    //封装类
public class Pareson {
    private int age;
    //读取方法
    public int read(){
        return age;
    }
    //设置
    public void set(int age){
        if (age >= 23) {
            this.age = 21;
        }else {
            this.age = age;
        }
    }
}

Pareson pareson = new Pareson();
        //pareson.age = 21;
        //设置
        pareson.set(224);
        //读取
        System.out.println(pareson.read());

继承

  • 类是对对象的抽象

  • 继承是对类的抽象

  • 先写父类，再写子类

  • 继承可以提高代码的复用性

  • 父类用private修饰的内容，子类可以间接调用

  • 子类(派生类)继承自(父类/基类/超类)

  • 继承具有传递性

  • 一个父类可以有多个子类，但是一个子类只能由一个父类，但是还可以间接继承其他类

    //父类
public class Person {
    private int age;
    private String name;
    private float height;

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public float getHeight() {
        return height;
    }

    public void setHeight(float height) {
        this.height = height;
    }
    //方法
    public void eat(){
        System.out.println("吃饭！");
    }
    public void sleep(){
        System.out.println("睡觉！");
    }
}
//子类
public class Student extends Person{
    //特有属性
    private int sno;

    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }
    //方法
    public void study(){
        System.out.println("学习！");
    }
}

public static void main(String[] args) {
        Student student = new Student();
        student.setSno(20);
        student.setAge(21);
        student.setHeight(165);
        student.setName("李三");

        System.out.println("学生名字: "+student.getName()+",学生学号: "+student.getSno()+",学生年龄: "+student.getAge()+",学生身高: "+student.getHeight());
        student.eat();
        student.sleep();
        student.study();
    }

小面试题：继承条件下构造器的执行过程

  1. 先做类的加载
  2. 然后加载类里面的构造器
  3. 然后构造器里面有父类的属性就去调用父类里面的属性
  4. 先调用父类里面的构造器，然后从父类里面的构造器去调用Object进行初始化
  5. 然后在逐一向上返回

多态

  • 多态与属性无关

  • 先有父类再有子类叫继承

  • 先有子类再有父类叫泛化

  • 什么是多态

    • 同一个行为，不同子类表现出来不同的形态
    • 同一个方法调用，由于对象不同会产生不同的行为

  • 多态的好处

    • 为了提高代码的扩展性
    • 符合面向对象的设计原则
      • 开闭原则
        • 开闭原则是指扩展是开发的，修改是关闭的

  • 多态的要素

    1. 继承
    2. 重写
    3. 父类引用指向子类对象

  • 多态的应用场合

    • 父类当做方法的形参，传入具体的子类的对象
    • 父类当做方法的返回值，返回的是具体发子类的对象
    • 接口当做方法的线程，传入具体的实现类的对象
    • 接口当做方法的返回值，返回的是具体的实现类的对象

简单的工厂设计模式

  • 这个简单工厂设计模式不属于23种设计模式

  • 这个设计模式不仅可以使用父类的方法做形参，还可以使用父类的方法作为返回值，返回值的对象可以是这个类的任意一个子类对象

  • 这个设计模式解决了大量的对象创建问题，是大量创建对象问题的一个解决方案

  • 将创建和使用分开，工厂只负责创建，使用者直接调用

  • 基本要求

    • 定义一个stati方法，通过类名直接调用
    • 返回值类型是父类类型，返回的可以是任意子类类型
    • 传入一个字符串类型的参数，工厂根据参数创建对应的子类产品

final修饰符

final修饰变量

  • final修饰一个变量，变量的值不可以改变，这个变量就变成了字符常量，一般名字大写，这是约定俗成的
  • final修饰引用数据类型，地址值是不可以改变的

final修饰方法

  • final修饰一个方法，这个方法就不能被这个类的子类重写

final修饰类

  • final修饰这个类，这个类不能被继承

抽象类

抽象类和抽象方法的关系

  • 抽象类中可以定义0~n个抽象方法

抽象类的作用

  • 在抽象类中定义抽象方法目的是为了给子类提供一个通用模板，子类可以在模板的基础上进行开发；先重写父类的方法，然后可以再扩展自己的内容。
  • 抽象类避免了子类设计的随意性，通过抽象类，子类的设计也变得更加严格，在某些程度上进行了限制，让子类更加通用
  • 抽象类可以被其他类继承

面试题

  • 抽象类不能创建对象，那抽象类中能否有构造器？
    • 抽象类中一定有构造器。
    • 构造器的作用是给子类初始化对象的时候先用super调用父类的构造器
  • 抽象类可以被final修饰吗？
    • 不能，因为抽象类设计的初衷就是被子类继承
    • 抽象类被final修饰了就不存在继承了也就没有子类了

接口

  • 类是类，接口是接口，都是一个层次的概念

  • 接口没有构造器

  • 接口通过interface声明

  • 在JDK1.8之前接口只有两个部分的内容

    • 常量
      • 固定修饰符：public，static，final
    • 抽象方法
      • 固定修饰符：public，abstract

  • 类和接口的关系

    • 类实现接口
    • 实现一个接口，实现类需要重写接口中的全部抽象方法
    • 如果没有全部重写抽象方法，这个类可以变成一个抽象类
    • Java只有单继承，但是有多实现
    • 先写继承再写实现
    • 接口不能创建对象

  • 接口与抽象类的区别

    • 接口是行为的抽象，是一种行为的规范；抽象是对类的抽象，是一种模板设计
    • 接口没有构造方法，而抽象类有构造方法，其方法一般给子类使用
    • 接口只有定义，不能有方法的实现，java 1.8中可以定义default方法体，而抽象类可以有定义与实现，方法可在抽象类中实现
    • 抽象体现出了继承关系，继承只能单继承
    • 接口提现出来了实现的关系，实现可以多实现
    • 接口强调特定功能的实现，而抽象类强调所属关系
    • 接口成员变量默认为public static final，必须赋初值，不能被修改；其所有的成员方法都是public abstract的
    • 抽象类中成员变量默认default，可在子类中被重新定义，也可被重新赋值；抽象方法被abstract修饰，不能被private、static、synchronized和native等修饰，必须以分号结尾，不带花括号

  • 在JDK1.8之后的接口新增非抽象方法

    • 被静态public default修饰的非抽象方法

      • default必须加上，不然会报错
      • 实现类中想要重写接口中的非抽象方法，default就不能加，不然会报错

    • 静态方法

      • static不可以省略不写
      • 静态方法不能被重写

  • 在接口中加入非抽象方法是为什么

    • 如果接口中只能定义抽象方法的话，修改接口中的内容对实现类的影响太大了，所有实现类都会受影响
    • 接口中加入非抽象方法，对实现类没有影响，想调用就去调用即可
posted @ 2022-10-17 00:40  理想还很年轻  阅读(23)  评论(0)    收藏  举报