Java基础面向对象——继承

3.2 继承

• 一种类与类之间的关系

• 使用已经存在的类的定义作为基础建立新类

• 新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类

！注意一个子类只能继承一个父类，且之类只能继承父类非私有成员

代码实现

父类

package 面向对象;
​
public class Animal {
    //公共的属性和方法
    private String name; //昵称
    private int month; //月份
    private String species; //品种
​
    public void eat(){
        System.out.println(this.getName()+"在吃东西");
    }
    public Animal() {
    }
​
    public String getName() {
        return name;
    }
​
    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", month=" + month +
                ", species='" + species + '\'' +
                '}';
    }
​
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getMonth() {
        return month;
    }
​
    public void setMonth(int month) {
        this.month = month;
    }
​
    public String getSpecies() {
        return species;
    }
​
    public void setSpecies(String species) {
        this.species = species;
    }
​
    public Animal(String name, int month, String species) {
        this.name = name;
        this.month = month;
        this.species = species;
    }
}

monkey子类

package 面向对象;
​
public class Monkey extends Animal {
    private double weight; //体重
​
    public Monkey() {
    }
​
    public Monkey(double weight) {
        this.weight = weight;
    }
​
    public Monkey(String name, int month, String species, double weight) {
        super(name, month, species);
        this.weight = weight;
    }
    public void run(){
        System.out.println(this.getName()+"是一只"+this.getSpecies()+",他在快乐的奔跑");
    }
}

dog子类

package 面向对象;
​
public class Dog extends Animal {
    private String sex; //性别
    public void sleep(){
        System.out.println(this.getName()+"现在"+this.getMonth()+"月大的，他在睡觉");
    }
    public Dog() {
    }
​
    public Dog(String sex) {
        this.sex = sex;
    }
​
    public Dog(String name, int month, String species, String sex) {
        super(name, month, species);
        this.sex = sex;
    }
​
    @Override
    public String toString() {
        return "Dog{" +
                "sex='" + sex + '\'' +
                '}';
    }
​
    public String getSex() {
        return sex;
    }
​
    public void setSex(String sex) {
        this.sex = sex;
    }
​
    public Dog(String name, int month, String species) {
        super(name, month, species);
    }
}

！父类不能调用子类的方法

！子类不能调用父类的私有方法

• 继承的特点

  • 1，利于代码复用

  • 2，缩短开发周期

3.2.1 方法重写

语法规则

• 在子类中定义

• 方法名

• 参数类型，顺序，个数

方法重写和方法重载的区别

• 方法重写

  • 在满足继承关系的子类中

  • 方法名，参数个数，顺序，类型与父类，返回值相同

  • 访问修饰符的限定范围大于等于父类方法

• 方法重载

  • 在同一个类中

  • 方法名相同

  • 参数个数，顺序，类型不同

  • 返回值和访问修饰符任意

3.2.3 访问修饰符

• 公有的：public

• 私有的：private

• 受保护的：protected

• 默认

3.2.4 实例化顺序

父类的静态变量
父类的静态块
子类的静态变量
子类的静态块
父类的非静态变量
父类的非静态块
父类构造方法
子类的非静态变量
子类的非静态块
子类的构造方法

3.2.5 super关键字

• 子类的构造的过程中必须调用其父类的构造方法

• 如果子类的构造方法中没有显示调用父类的构造方法，则系统 系默认调用父类无参的构造方法

• 如果子类构造方法中既没有显式调用父类的构造方法，而父类 又没有无参的构造方法，则编译出错

• 使用super调用父类指定构造方法，必须在子类的构造方法的 第一行

3.2.6 object类

• object类所有类的父类

• 一个类没有使用extends关键字明确标识继承关系则默认继承object类（包括数组）

• Java 中的每个类都可以使用object中定义的方法

object类常用方法

方法	说明
toString（）	返回当前对象本身的有关信息
equals（）	比较两个对象是否是同一个对象
hashCode（）	返回该对象的哈希代码值
getClass（）	获取当前对象所属的类信息，返回class对象

3.2.7 final关键字

1，修饰类表示不允许被继承

2，修饰方法表示不允许被子类重写

-final修饰的方法可以被继承

-不能修饰构造方法

3，修饰变量表示不允许修改

• 方法内部的局部变量 》在使用之前被初始化赋值即可

• 类中成员变量 》 只能在定义时或者构造代码块，构造方法中进行初始化设置

• 基本数据类型的变量 》 初始赋值之后不能更改

• 引用类型的变量 》 初始化之后不能再指向另一个对象，但指向的对象的内容是可变的

4，可配合static使用 当作不可修改的全局变量

5，使用 final修饰可以提高性能但会降低可扩展性

3.2.8 单例模式

设计模式

• 设计模式（Design pattern）是一套被反复使用，多数人知晓的经过分类编目的，代码设计经验的总结。

• 设计模式是软件开发人员再软件开发过程中面临的一般问题的解决方案

设计模式的种类

• 面向对象的设计模式很多，但大家认为这23个模式是其他模式的基础

单例模式要点：

• 1. 某个类只能有一个实例

  2. 必须自行创建实例

  3. 必须自行向整个系统提供这个实例

单例模式实现：

• 1. 只提供私有的构造方法

  2. 含有一个该类的静态私有对象

  3. 提供一个静态的共有方法用于创建，获取静态私有对象

代码实现方式：

1. 饿汉式

2. 懒汉式

饿汉式

代码实现

package 单例模式;
//饿汉式：创建对象实例的时候直接初始化
// 空间换时间
public class SingletonOne {
    // 1. 创建类中私有构造
    private SingletonOne(){
​
    }
    // 2. 创建该类型的私有静态实例
    private static SingletonOne instance = new SingletonOne();
​
    // 3. 创建公有静态方法返回静态实例对象
    public static SingletonOne getInstance(){
        return instance;
    }
}

懒汉式

代码实现

package 单例模式;
//懒汉式
public class SingletonTwo {
    // 1 创建私有的构造方法
    private SingletonTwo(){
​
    }
​
    //2 创建静态的该类实例对象
    private static SingletonTwo singletonTwo;
​
    //3 创建开放的静态方法提供实例对象
    public static SingletonTwo getInstance(){
        if (singletonTwo==null){
            singletonTwo=new SingletonTwo();
        }
        return singletonTwo;
    }
}

饿汉式对比懒汉式

• 饿汉式

  • 在类加载时就创建实例，第一次加载速度块

  • 饿汉式：空间换时间

• l懒汉式

  • 懒汉式第一次使用时进行实例化，第一次加载慢

  • 懒汉式：时间换空间

• 饿汉式线程安全；懒汉式存在线程风险 解决方案：

• 1、同步锁 2、静态内部类 3、双重校验锁 4、枚举

单例模式的优点:

1. 在内存中只有一个对象，节省内存空间

2. 避免频繁的创建销毁对象，提高性能

3. 避免对共享资源的多重占用

缺点

1. 扩展比较困难

2. 如果实例化后的对象长期不利用，系统将默认为垃圾进行回收， 造成对象状态丢失

适用场景

1. 创建对象时占用资源过多，但同时又需要用到该类对象

2. 对系统内资源要求统一读写，如读写配置信息

3. 当多个实例存在可能引起程序逻辑错误，如号码生成器