Java语法封装之继承、访问权限修饰符、重载与重写、this与super、final、Javabean的使用

3.3封装

封装 : 隐藏内部的实现细节,对外提供公共的访问方式。方法,类,属性的私有化… 都是封装的体现

封装优点 :
提高程序的安全性
提高代码的复用性

私有是封装，但是封装不是私有

3.3.1 继承

继承：子承父业。子类又称派生类，父类又称基类或者超类。父类是子类共性的类。

• 定义：

  • 子类 extends 父类

• 目的：

  • 提高代码的复用性

• 作用:

• 子类一旦继承父类,有权使用父类中的成员变量或者成员方法,也可以在子类中定义子类独有的内容

• 特点：

  • 单继承机制 ,一个子类只能继承一个父类,但是一个父类可以存在多个子类
  • 修饰类只能使用public|default(默认)
  • 开闭原则–> 面试对象设计原则之一 : 对修改关闭,对扩展开放

• 实体类|子类 :

  • 根据一系列对象抽取共性所定义的实体类

• 单继承的优缺点 :

  • 优点： 简单
  • 缺点：不便于后期维护

public class Class001_Extends {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.name = "马云";
        t.age = 50;
        t.subject = "英语";
        t.teach();
        t.sleep();
    }
}

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

    public void sleep(){
        System.out.println(name+"在休息");
    }
}

//子类
class Teacher extends Person{
    public String subject;  //教授学科

    //构造器
    public Teacher(){

    }
    public void teach(){
        System.out.println("教书育人!!!");
    }
}
//子类
class Student extends Person{
    public int num;  //学号

    //构造器
    public Student(){

    }

    public void study(){
        System.out.println("学习!!!");
    }
}

3.3.2 访问权限修饰符

private,default,protected,public

	本类	同包类	不同包下继承的类	不同包下的其他类
private私有的	√
default默认的	√	√
protected受保护的	√	√	√
public公共的	√	√	√	√

• 注意：
  • 四个访问权限修饰符都是成员修饰符,只能修饰成员,不能修饰局部
  • 能够修饰类的 : public | default
  • Protected修饰的成员在不同包下的子类中,需要通过继承关系使用
  • 最常用的两种权限 : public|private

public class Class001_Modifier {
   public String  testPublic = "public";
   protected String  testProtected = "protected";
   String  testDefault = "default";
   private String  testPrivate = "private";

   public static void main(String[] args) {
        new Class001_Modifier().test();
   }

   public void test(){
       //测试本类中使用
       System.out.println(testPublic);
       System.out.println(testProtected);
       System.out.println(testDefault);
       System.out.println(testPrivate);
   }

   public static void testStatic(){
       //测试本类中使用
       Class001_Modifier cm = new Class001_Modifier();
       System.out.println(cm.testPublic);
       System.out.println(cm.testProtected);
       System.out.println(cm.testDefault);
       System.out.println(cm.testPrivate);
   }

}
//同包类
class Demo{
    public static void main(String[] args) {
        //测试本类中使用
        Class001_Modifier cm = new Class001_Modifier();
        System.out.println(cm.testPublic);
        System.out.println(cm.testProtected);
        System.out.println(cm.testDefault);
        //System.out.println(cm.testPrivate);
    }
}

3.3.3 super的使用

1. super 与 this 之间的区别:

• this 指代当前new对象
  • 本类构造器的首行调用本类中的其他构造器this(参数列表)
  • 区分局部与成员同名问题
    • 默认就近原则
    • 通过this.调用成员
• super 指代父类对象
  • 子类构造器的首行,通过super(参数)调用父类中的指定构造器
    • 如果没有显示通过super(参数)调用,默认调用父类的空构造
  • 区分子父类中同名成员
    • 如果不存在同名问题 : 可以省略super.调用父类成员
    • 如果存在子父类同名成员问题,同名局部问题 :
      • 默认就近原则
      • 有局部找局部
      • 通过this.找子类成员
      • 通过super.找父类成员

2. 注意：

• 子父类继承关系下 : 创建子类对象的时候,其实会先父类后子类
• 不能在构造器的首行同时使用this(参数)与super(参数)
• this与super都不能使用在静态方法中

public class Class_Super {
    public static void main(String[] args) {
        Zi zi = new Zi();//创建子类对象的时候,其实会先父类后子类,故输出有父类中有一个参数的构造器
        zi.test();//输出Fu 1个参数；FuStr；ZiStr
        System.out.println(zi.str);
    }
}

class Fu {
    String str = "FuStr";

    public Fu() {
        System.out.println("Fu");
    }

    public Fu(int i) {
        System.out.println("Fu 1个参数");
    }
}

class Zi extends Fu {
    String str = "ZiStr";

    public Zi() {
        super(100);//调用父类有一个参数的构造器
    }

    public Zi(String str) {
        this();//调用本类中的没有参数的构造器
        System.out.println("Zi 一个参数");
    }

    public void test() {
        System.out.println(super.str);
    }
}

3.3.4 重写

1. 重写与重载之间的区别 ：都是方法的特性

• 重载的实现条件 :
  1. 一个类中的多个方法
  2. 方法名相同
  3. 参数列表不同|方法签名不同
• 重写的实现条件:
  1. 两个类
  2. 类之间有继承|实现关系
  3. 方法签名（方法名和参数列表）完全相同

2.重写的需求 :

• 当子类从父类中继承的功能满意,对功能实现不满意的时候,可以在子类对从父类中继承的功能重新实现

3.调用使用 :

• 如果子类中没有重写,调用父类的,父类没有报错
• 如果子类存在重写方法,调用子类中重写后的方法,对父类的方法进行屏蔽

4.检测是否为重写方法 :

• idea行号后面的位置出现o向上箭头
• 在重写方法上添加注解 @Override

5.不能被重写的方法 :

• 被private修饰的方法不能被重写，能被子类继承,但是无权使用
• 被final修饰的方法不能被重写
• 被static修饰的方法不能被重写
  • 可以被继承不能被重写
  • 如果子类中出现与父类中静态方法同名的方法,要求子类中这个同名的方法也被static修饰

public class Class001_Override {
    public static void main(String[] args) {
        SiCong siCong = new SiCong();
        siCong.words();
        siCong.test();//输出：我在不在乎我的朋友有钱没有,反正都没我有钱...
    }
}

class JianLin{
    String name = "王健林";

    //名人名言
    public static void words(){
        System.out.println("先定义小目标,挣它一个亿...");
    }

    public static void test(){}
}

class SiCong extends JianLin{
    String name = "王思聪";

    //重写方法
    public static void words(){
        System.out.println("我在不在乎我的朋友有钱没有,反正都没我有钱...");
    }
}

输出：我在不在乎我的朋友有钱没有,反正都没我有钱...

3.3.5 final

final 最终的

• 被final修饰的变量为常量
• 被final修饰的方法不能被重写
• 被final修饰的类不能被继承–>太监类

public class Class001_Final {
    final static Student s = new Student();
    public static void main(String[] args) {
        //s = new Student();
        System.out.println(s.age);
        s.age++; //只修改了对象内存空间中的属性值,没有修改s存储对象地址值,所有s还是常量
        System.out.println(s.age);
    }
}

class Student{
    int age = 18;
}

输出：
18
19

3.3.6 Javabean

Javabean : 一系列实体类的统称

• 定义规范 :

  1. 类是公共的
  2. 至少一个空构造
  3. 属性私有化
  4. 提供一对公共的访问方式

• 安全隐患问题 :

  • 属性赋值,值有可能出现符合类型范围要求但是不符合业务要求的数据

• 私有属性配合一对公共的访问方式使用的原因

  • 私有属性需要配合提供一对公共的访问方式–> 方法,因为在方法中可以做逻辑判断
    • 设置器 setter : 为私有属性设置值
    • 访问器 getter : 获取私有属性

• 注意:

  • 定义实体类时属性都需要私有化,并且提供一对公共的访问方式

public class Class001_Private {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("杨聪");
        //s.age = -18;
        s.setAge(28);

        s.show();
        System.out.println(s.getAge());
    }
}

class Student{
    private String name;
    private int age;

    //设置器 : 为age设置值
    public void setAge(int age){
        if(age<0 || age>40){
            System.out.println(age+"年龄不合法");
            return;
        }
        this.age = age;
    }

    //访问器 : 获取age的值
    public int getAge(){
        return this.age;
    }

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

    public String getName(){
        return name;
    }

    public Student(){}

    public void show(){
        System.out.println(name+"--->"+age);
    }
}