一篇文章让你精通面向对象特征（封装，继承与多态）

Posted 2021-08-29 韶光不负

在Java面向对象中有非常重要的三个属性，封装，继承与多态，让我们了了解了解它们的重要性吧！

访问修饰符

访问修饰符

public	公共的，在任何地方都可以正常访问，权限最大
protected	受保护的，同包和子类可以访问（不能修饰类），权限第二
默认（不写）	缺省，在同包中访问，权限第三
private	私人的，同类可以访问（修饰类成员，不能修饰类），权限第三。

注意：private与protected不能修饰类

封装 

什么是封装

将类的属性私有化，不向外界提供直接访问属性的方式。

提供对应的getter与setter方法来访问和设置属性。

封装的作用

实现数据的安全，与私有化。（小编认为就是风险的操作，把它私有化不让外界访问，但提供安全的方式，让你查看与设置）

封装的使用（JDEA快捷方式：alt+insert ：选择 Getter and Setter）

public class Text {
    public static void main(String[] args) {
        Perple p=new Perple();
        p.setName("小罗");
        System.out.println(p.getName());
        p.setGender("男");
        System.out.println(p.getGender());
        p.setTell("130xxxxxxxxx");
        System.out.println(p.getTell());
    }
}
//
class Perple{
    //私有化属性
    private String name;
    private String gender;
    private String tell;
    
    //提供公共方法让外界访问与设置属性
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getGender(){
        return this.gender;
    }
    public void setGender(String gender){
        this.gender=gender;
    }
    public String getTell(){
        return this.tell;
    }
    public void setTell(String tell){
        this.tell=tell;
    }
    

}

toString 方法（快速展示终端数据，用来测试数据）

（objects默认是所有类的父类，简称超类）

Java中想在控制台上打印对象，默认调用objects的toString方法打印的是 包全路径（包路径+类名称）+内存地址哈希值。

 toString方法重写：（快捷键alt+insert 选择toString ）

 @Override
    public String toString() {
        return "Perple{" +
                "name='" + name + '\\'' +
                ", gender='" + gender + '\\'' +
                ", tell='" + tell + '\\'' +
                '}';
    }

JOPO（对象模型：一个标准Java bean）

一个标准对象模型为一个类中有私有化属性，属性的get与set方法，全部参数的构造函数，一个无参的构造函数和toString方法：

继承

什么是继承

继承类称为子类（派生类）

被继承类称为父类（基类）

一个类继承另一个类，此时这个类会继承另一个父类中的能够继承的成员（方法）

继承的作用

子类继承父类能够的继承的方法与成员属性，减少了代码重复量，提高代码复用性。

当继承中调用函数先找自己，再找父类，继续向上找。

继承的使用

使用关键字extends,（不同的包要导包只能继承 public与protected修饰的类，同包中不能继承private修饰。私有化不能继承）

//父类
class Perple{
    public String getName() {
        return name;
    }

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

    //私有化属性
    private String name;
    private String gender;
    private String tell;

    //提供公共方法让外界访问与设置属性


    public String getGender(){
        return this.gender;
    }
    public void setGender(String gender){
        this.gender=gender;
    }
    public String getTell(){
        return this.tell;
    }
    public void setTell(String tell){
        this.tell=tell;
    }

    @Override
    public String toString() {
        return "Perple{" +
                "name='" + name + '\\'' +
                ", gender='" + gender + '\\'' +
                ", tell='" + tell + '\\'' +
                '}';
    }
    public void say(){
        System.out.println("Perple说的话");
    }

}

//子类继承Perple
public class Son extends Perple {
    public static void main(String[] args) {
        Son n=new Son();
        n.say();
    }
}

覆盖|重写（不能改父类的方法）

什么要覆盖|重写（本质是调用函数的顺序，先调用自身，再向上查找调用）

当继承父类的方法不能够满足子类的要求时，子类重写该方法，满足自己的使用

如何重写父类方法

在子类中定义相同名称的方法

1，重写名称必须相同

2，自能改变访问修饰符，访问修饰符必须比父类访问修饰符的权限大或相同。

public class Son extends Perple {
    public static void main(String[] args) {
        Son n=new Son();
        n.say();
    }
    //重写父类方法名称必须相同
    public void say(){
        System.out.println("Son说的话");
    }
}

如何查看重写方法（jdk1.5引用）

@Override //注解

子类重写父类函数时，可以添加@Override注解，当父类没有此函数加上注解就会报错！

如何在子类重写后调用父类方法（super关键字）

public class Son extends Perple {
    public static void main(String[] args) {
        Son n=new Son();
        n.say1();
    }
    //重写父类方法名称必须相同
    @Override
    public void say(){
        System.out.println("Son说的话");
    }
    private void say1(){
        //调用父类的方法
        super.say();
    }
}

继承列

Java是单继承机制：一个类只能继承一个父类！

Java中存在一个根类objects类。如果一个类没有父类，默认继承objects类。

 内部类（在Java中大量使用,因为内部就可以实现多继承）

一般而言，定义在内部类，主要目的，在包裹着它的外部类中使用它。

作用：直接访问任何属性与方法（包括私有化）

public class TextInnerClass {
    private int id =1;

    public static void main(String[] args) {
        Inner_one t=new Inner_one();
        t.say();
    }
    //定义一个内部类
    public class  Inner_one{
        //作用：直接访问内部属性
        public void say(){
            TextInnerClass t=new TextInnerClass();
            System.out.println(t.id);
        }
    }
     //定义一个静态内部类
    //public static class  Inner_one{
        //作用：直接访问内部属性
      //  public void say(){
        //    TextInnerClass t=new TextInnerClass();
          //  System.out.println(t.id);
        //}
   // }
}

面试题：在外界初始化内部类对象！

 public void say(){ 
        //外部调用内部类
        TextInnerClass.Inner_one t1 = new TextInnerClass.new Inner_one();
        t1.say();
    }

//public void say(){
        //外部调用静态内部类型
  //      TextInnerClass.Inner_one t1 = new TextInnerClass.Inner_one();
    //    t1.say();
        
    //}

多态 （继承的基础上，进行类型的转化）

什么是多态

多态是在继承的基础上存在的，父类引用指向子类实例！此时的父类可以代表全部子类对象。

多态的作用

1.对设计和架构的复用，针对接口编程而不是针对实现编程就是充分利用多态的典型例子。

2.定义功能和组件时定义接口，实现可以留到之后的流程中。同时一个接口可以有多个实现，甚至于完全可以在一个设计中同时使用一个接口的多种实现(例如针对ArrayList和LinkedList不同的特性决定究竟采用哪种实现)。

多态的使用

// 父类引用   = 子类实现
 父类名称 变量名称 =new 子类名称;

public class Text {
    public static void main(String[] args) {
        Xiaoming x=new Xiaoming();
        x.setName("小明");
        //多态
        // 父类引用   = 子类实现
        Perple pel=new Xiaoming();
        
    }
}

class  Perple{
    public String getName() {
        return name;
    }

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

    //私有化属性
    private String name;
    private String gender;
    private String tell;

    //提供公共方法让外界访问与设置属性


    public String getGender(){
        return this.gender;
    }
    public void setGender(String gender){
        this.gender=gender;
    }
    public String getTell(){
        return this.tell;
    }
    public void setTell(String tell){
        this.tell=tell;
    }

    @Override
    public  String toString() {
        return "Perple{" +
                "name='" + name + '\\'' +
                ", gender='" + gender + '\\'' +
                ", tell='" + tell + '\\'' +
                '}';
    }
    public void say(){
        System.out.println("Perple说的话");
    }

}

class Xiaoming extends Perple{
    
}

面向对象中关键字 

 instanceof关键字

 instanceof 作用（返回布尔值）： 前面参数 是否为 后面对象的实例

 Son n=new Son();
 // instanceof关键字
 System.out.println(n instanceof Son);

final关键字

1，final修饰变量，会使用变量为常量

 //修饰变量，变量设置为常量，不能修改
    public static final 变量类型 名称;

2，final修饰类，该类是最终类，不允许被继承。（如:字符串的类 ，Integer,Math等等基础类）

public final class 类名称 {
    //修饰类，该类不能被继承
   
}

 3，final修饰方法，该方法为最终类方法，不允许被继重写（Over read）。

public final void 名称(参数) {
        //函数体
    }

面试题：为什么字符串的类设计为final。

1，jdk认为String类为基础的类，不应该进行再生。

2，许多的基础包装类会被提前加载到程序当中，提高了效率。