Java-Day008

成功是别人失败时还在坚持

• 封装
  • 访问权限
  • JavaBean
• 继承
  • 继承
  • 重写
  • Object继承链
  • 实例化过程
  • super
  • final

一、Java的三大特性

• 封装
• 继承
• 多态

1、封装

1.1、理解

封装就是把某些东西进行封装，就比如把计算机电脑进行封装，看不到内部，只需要从计算机给定的一些接口进行计算机操作就行了。

1.2、概念

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

1.3、作用

• 实现了专业的分工，将能实现某些功能的代码封装成一个独立的实体后，各程序员可以在需要的时候调用，从而实现了专业的分工，即工作中的分模块，分功能开发。
• 隐藏信息，实现细节，通过访问控制权限可以将不想让客户端程序眼看到的信息隐藏起来。

2、继承

2.1、理解

如同字面意思一样，就是继承家产，老子有的儿子继承了父亲的，那么儿子也就有了。

2.2、概念

一个类继承另一个类，则称继承的类为子类，被继承的类为父类。、

2.3、作用

实现代码的复用，延续+扩展父类信息。子类继承了父类，就拥有了父类的属性和方法（有条件的），这样就可以少写一部分代码。

3、多态

3.1、理解

多态是同一个行为具有多个不同表现形式或形态的能力。

3.2、概念

相同的事物调用其相同的方法，表现出不同的行为。

3.3、作用

提高代码的可复用性。

二、封装

前面说了，封装就是把一些功能或者不想让被人看到的隐藏起来

1、访问权限

通过访问权限来达到不想让别人看到的作用

	同一个类	同一个包中	子类	所有类
private	√	√
defaule	√	√
protected	√	√	√
public	√	√	√	√

• private：只能自己访问
• defaule：只能自己和同一个包内的类访问
• protected：只能自己和同一个包里的类或者子类访问
• public：谁都可以访问

权限修饰符可以用来修饰类、方法、属性

2、JavaBean

JavaBean 是一种JAVA语言写成的可重用组件。为写成JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。JavaBean 通过提供符合一致性设计模式的公共方法将内部域暴露成员属性，set和get方法获取。众所周知，属性名称符合这种模式，其他Java 类可以通过自省机制(反射机制)发现和操作这些JavaBean 的属性。

public class Person {
    private String name;
    private boolean sex;
    private int age;

    public String getName() {
        return name;
    }

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

    public boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

Tips：如果是boolean类型的值，在获取数据的时候不是使用get方法，而是使用is

三、继承

1、继承

1.1、语法规则

[修饰符] class 类名 extends [父类名字]{}

1.2、例子

父类

public class Person {
    private String name;
    private boolean sex;
    private int age;

    public String getName() {
        return name;
    }

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

    public boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

子类

public class Student extends Person{

}

Tips：Java的一个类只能继承一个父类，但是父类可以再继承父类，一直向上继承，形成祖父孙的关系

继承之后，子类自动拥有了父类的成员变量和方法(合法修饰范围内)

public class Test1 {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        System.out.println(student.getName());
    }
}

运行结果
张三

2、重写

有时候，继承的父类的方法可能达不到子类想要的功能，这时就需要重写父类的方法。

2.1、重写

父类

public class Person {
    private String name;
    private boolean sex;
    private int age;

    public String getName() {
        return name;
    }

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

    public boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public void study(){
        System.out.println("学习");
    }
}

子类

public class Student extends Person{
    @Override
    public void study() {
        System.out.println(getName()+"在学习");
    }
}

测试类

public class Test1 {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        student.study();
    }
}

运行结果
张三在学习

Tips：注意子类的重写方法上要加上@Override

2.2、重写的要求

• 重写的方法名和参数列表要和父类被重写的方法的方法名和参数列表相同
• 重写的方法名的基本类型返回值类型要和父类被重写的方法的基本类型返回值类型相同，如果是引用类型，那么重写的方法的返回值类型，要小于父类被重写的返回值类型。
• 重写的方法名的访问权限要大于或等于父类被重写的方法的访问权限

注意：

• 属性不会被重写
• 静态方法不会重写
  • 父类是静态方法，如果非要在子类里面写必须要给子类的方法加上静态修饰符，而且这种现象不会形成重写。
• final修饰的方法不能重写
• 私有方法不会被重写

3、Object继承链

Object是所有类的根基类

如果未在类中声明使用extends继承Object，那么系统默认继承Object类

public class A {
    
}

等同于

public class A extends Object{

}

如果指定了继承的父类，则不会继承Object类

但是由于Java可以祖孙继承，就算子类不继承，那么父类也有可能会默认继承Object类

4、super关键字

和this一样，不过super代表的是父类的信息，或者父类的构造器

super只能在继承关系的类中使用

父类

public class Person {
    private String name;
    private boolean sex;
    private int age;

    public String getName() {
        return name;
    }

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

    public boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

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

子类

public class Student extends Person{
    private String name;
    @Override
    public void study() {
        name = super.getName();
        System.out.println(this.name+"在学习");
    }
}

测试类

public class Test1 {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        student.study();
    }
}

运行结果
张三在学习

调用子类构造器会先调用父类构造器

父类

public class Person {
    public String name;
    private int age;

    public Person() {
        System.out.println("父类构造器");
    }
    
    public int getAge() {
        return age;
    }

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

子类

public class Student extends Person {
    public Student() {
        System.out.println("子类构造器");
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Student student = new Student();    // 调用子类构造器会先调用父类构造器
    }
}

运行结果
父类构造器 子类构造器

• suoer()：调用父类构造器
• super.属性：调用父类属性
• super.方法()：调用父类方法

5、final关键字

final有几个用途

• 表示常量
• 修饰类，被final修饰的类不能被继承
• 修饰方法，被final修饰的方法不能被重写

6、实例化过程

• 如果没有继承关系，自己调用自己构造器初始化就完了
• 如果存在继承关系，如果创建子类对象，会先调用父类构造器
  • 从父类开始，父类构建完毕才会构建子类
  • 在构造父类的过程中，必须根据父类的构造器去调用，父类必须提供合适的构造器
  • 如果父类不存在无参构造器，那么子类必须显示的使用super(参数)去调用父类的带参构造
  • super关键字必写在第一行

7、继承链

就是有继承关系的一条看不见的链，叫做继承链。

在找一个方法的时候，从本类开始找，如果本类找不到就去父类找，一直找，找到Object类，如果在所有的类中都找不到（找到Object），那么就报错