Java从入门到精通（四）· 面向对象

Java从入门到精通（四）· 面向对象

一 静态关键字（static）

static表示静态关键字，可以用来修饰成员变量和成员方法。

被 static修饰的成员变量，称之为静态成员变量或者类变量，同理可得，被修饰的成员方法称之为静态成员方法或者类方法。

public static String name="shawn";
void test(){
    System.out.println(name);
    System.out.println(Study08Static.name);
}

一般情况下，使用类名直接来访问类变量。

被 static 修饰的关键字的特点：

属于类，与类一起加载，在内存中只有一份，会被类的所有对象共享

二 继承

1.继承的介绍

使用 extends 关键字，可以让一个类与另一个类建立起父子关系。

继承的特点：

• 子类能够继承父类的非私有成员
• 子类的对象是有子类和父类共同完成
• 减少重复代码

@Data
public class Pupil extends Student {
    private String className;
    private String teacher;
}

Java 中不支持多继承，仅支持单继承，即只能继承一个多父类。

2.Object类

所有的类都默认继承了Object 类。

3.方法重写

即子类重新实现父类中已存在的方法，称之为方法重写

重写父类方法需要使用 @Override 注解

public class Parent {
    public void getName(){
        System.out.println("shawn");
    }
}
//*********************************************
public class Son extends Parent {
    @Override
    public void getName() {
        System.out.println("alice");
    }
}

4.super 关键字

在子类范围访问父类的方法，如果已经对该方法进行了重写，则必须使用 super 关键字访问。

5.构造器特点

子类的全部构造器，都会先调用父类的构造器，再执行自己。

如果父类有多个构造器，则可以显示声明需要调用哪个构造器。

也可以使用 this 关键字，调用兄弟构造器

public class Parent {
    public Parent(){
        // 使用 this 关键字调用兄弟构造器
        this("shawn");
    }
    public Parent(String name){
        System.out.println(name);
    }
}

使用 super 或 this 关键字调用其他构造器时，super 或 this 必须放在第一行。由此可得， super 和 this 不能同时使用。

三 访问修饰符

访问修饰符被来用限制类中的成员能够被访问的范围。

private < 缺省 < protected < public

四 多态

1.多态的概念

多态是在继承（extends）、实现(implements) 情况下的一种现象，表现为：对象多态，行为多态。

People p1=new Student();
p1.work();
People p2=new Teacher();
p2.work();

其中，p1 与 p2 表现为对象多态，而 p1.work() 和 p2.work() 表现为行为多态。

多态的特点：编译看左边，运行看右边

2.多态的优缺点

1.多态形式下，右边对象是解耦合的，更便于维护和扩展。

解释：右边的对象如果不好用，则直接更换对象即可，无需再改动其他代码

2.定义方法时，使用父类类型的形参，可以接收一切子类对象，扩展性更强，更便利

3.多态的缺点：多态下的父类对象，无法使用子类的独有功能

3.多态的类型转换

• 自动类型转换：父类 变量名=new 子类（）
• 强制类型转换：子类 变量名=(子类)父类变量

People student=new Student();
student.work();
Student stu=(Student)student;
stu.test();

注意事项：编译阶段的类型强转不会报错，但是运行阶段如果发现两个类型不能相互转换则会抛出异常

建议：强转前最好使用 instanceof 关键字，判断当前对象的真实类型，然后再进行强转

People p1=new Student();
p1.work();
if(p1 instanceof Student){
    Student stu=(Student)p1;
    stu.test();
}

五 final关键字

final 关键字，表示为”最终“的意思，一般可以用来修饰类，方法，变量。

• 修饰类：该类被称为最终类，特点是该类不能被继承
• 修饰方法：该方法被称为最终方法，特点是无法被重写
• 修饰变量：该变量能且只能被赋值一次

注意：

如果 final 修饰基本类型的变量，则变量存储的数据不能被改变。

如果 final 修饰引用类型的变量，则变量存储的地址不能被改变，但是地址所指向的内容是可以被改变的。

// 数组（引用类型）的地址所指向的内容可以改变
final int [] number={1,2,34};
number[2]=111;
// 数组（引用类型）的地址不能改变（以下示例会报错）
final int [] number={1,2,34};
number[2]=111;
int [] number2={1,2,3,4};
number=number2;

使用 static final 修饰的成员变量一般被称之为常量。

常量通常用于记录一些配置信息，或是经常在项目中使用但是却不允许被修改的数据。

程序编译后，常量会被“宏替换”，即出现常量的地方都将会被替换为字面量，这样可以保证使用常量和使用字面量的性能是完全一样的。

宏替换是C/C++编程中的一个重要概念，它是在预处理阶段进行的一种文本替换机制。通过使用宏定义，可以将一段代码片段或常量定义替换为预定义的文本。

六 抽象类

1.概述

被 abstract 修饰的类，叫做抽象类，其中 abstract 就是抽象的含义，abstract 关键字可以修饰 类 和 成员方法

基本语法： [访问修饰符] abstract [class关键字] 类名

@Data
public abstract class AbstractParent {
    /**
     * 抽象类中的抽象方法
     */
    public abstract void getName();
    public void getAge(){
        System.out.println("抽象类中的非抽象方法");
    };
     /**
     * 抽象类中的成员属性
     */
    private String name;
}

abstract 修饰类，则该类就是抽象类，abstract 修饰方法，则该方法就是抽象方法（抽象方法必须存在于抽象类中）。

抽象方法只有方法定义，没有方法体！！！

• 抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类（抽象方法必须存在于抽象类中）
• 类该有的成员（成员变量，构造函数，方法）抽象类都可以有
• 一个类继承了抽象类，则必须完整实现抽象类中的全部抽象方法，除非这个类也是抽象类

抽象类最重要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现

2.优点

父类直到每个子类都要做某个行为，但是每个子类要做的情况不一样。这种情况下就可以将父类定义为抽象类，交给子类去重写实现。

这样设计的抽象类，可以更好的支持多态。

3.模板方法设计模式

模板方法设计模式主要用来解决方法中存在重复代码的问题

模版方法设计模式的写法：

• 定义一个抽象类
• 在里面定义两个方法：一个是模板方法，将重复代码放进去，另一个是抽象方法，具体交给子类实现

以下是抽象类：

public abstract class AbstractParent {
    /**
     * 抽象类中的抽象方法
     */
    public abstract void getName();

    public abstract void getSex();
    
    // 这里的getinfo()就是模板方法，
    public final void getInfo(){
        getName();
        System.out.println("这是我的年龄啊");
        getSex();
    }
}

以下是抽象类的实现类：

public class ExtendsSon extends AbstractParent {
    @Override
    public void getName() {
        System.out.println("这是名字");
    }
    @Override
    public void getSex() {
        System.out.println("这是性别");
    }
}

演示示例：

public static void main(String[] args) {
    AbstractParent abstractParent=new ExtendsSon();
    abstractParent.getInfo();
}

为放置模板方法被重写，可以对模板方法添加final关键字

七 接口

1.概述

Java提供了一个关键字 interface，使用这个关键字可以用来定义接口。接口中包含成员变量，成员方法。

public interface A {
    /**
     * 在接口中定义的成员变量，默认为常量
     */
    String studentName="Shawn";
    /**
     * 定义接口（省略访问修饰符，接口中定义的方法默认为抽象方法）
     */
    void getName();
}

特点：接口不能创建对象，接口是用来被实现的

2.优点

接口的好处：

• 弥补了类只能单继承的不足，一个类可以同时实现多个接口
• 让程序可以面向接口编程，方便灵活的切换各种业务

3.接口中的其他成员

JDK8以后，接口中新增的三种方法：

• 默认方法：必须使用 default 关键字修饰，默认会被 public 修饰，且JDK8以后开始支持
• 私有方法：必须使用 private 修饰，只能在默认方法中使用，且JDK9以后才开始支持
• 静态方法：JDK8以后，接口中可以定义静态方法，需要使用 static 关键字修饰，无需访问修饰符

public interface B {
    /**
     * 默认方法 必须使用 `default` 关键字修饰，默认会被 `public` 修饰
     * @return
     */
    default String getName(){
        System.out.println("仅仅是测试");
        getAge();
        return "shawn";
    }
    /**
     * 接口中的私有方法
     */
    private void getAge(){
        System.out.println("这是私有方法");
    }
    /**
     * 接口中的静态方法
     */
    static void getAge(){
        System.out.println("接口中的静态方法");
    }
}

增加以上三种方法的原因：

• 增强了接口的功能，可以直接编写方法
• 可以为实现类扩展通用性的功能，而不需要实现类去实现

4.多继承的注意事项

同时集成的多个接口中如果存在名称冲突的方法，此时则无法进行多继承。

如果接口中存在与实现类同名的默认方法，则优先调用接口中的默认方法