面向对象编程基础-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_63136968/article/details/127727043

面向对象目录
1 类与对象
2 封装
2.1 构造方法
2.2 类的结构
3 继承
3.1 类的设计与扩展
4 接口
4.1 事件监听器
5 抽象类
6 泛型
7 枚举

2 封装

2.2 类的结构

类中有什么？

1）属性。

2）方法，包括普通方法和构造方法。

3）代码块。

4）静态资源，用static修饰，由类名可以直接调用，包括静态变量和静态方法。

3 继承

3.1 为什么要继承？

3.2 继承的格式

1）关键字：extends继承（类）；implements实现（接口）。

2）继承只能继承一个类，实现可以实现多个接口。

继承的格式：public class 子类名 extends 父类名{}

实现接口的格式：public class 接口的实现类名 implements 接口名1,接口名2,...{}

继承+实现接口的格式：public class 类名 extends 父类名 implements 接口名1,接口名2,...{}

3.3 子类继承了父类的哪些内容？子类可以直接调用父类的哪些内容？

1）子类继承了父类的所有内容。但是，有些内容，虽然继承了，但不能直接调用。

2）按照2.2的介绍，逐项分析子类可以继承、调用的父类的内容：

属性。会继承给子类。

方法。普通方法，子类会继承。构造方法，子类会直接向上调用，连着父类的构造方法一起调用，既会调用自己的构造方法，又会调用父类的构造方法。

代码块。子类会直接执行父类的代码块。

静态资源。由类名可以直接调用。子类也可以调用。

3）关于子类能否直接调用父类的属性和普通方法，要看访问权限修饰符。

访问权限修饰符限制了代码可以使用的范围，具体如下：

- 项目

        - src：自己的代码

                - package：包

                        - 类文件（.java）

                                - 类

        - lib：java源码、导入的其他代码

public	整个项目下
private	只能在本类中使用
protected（受保护的）	同包下&子类中
缺省不写	同包下

3.4 方法重写

1）子类中重写父类方法

子类中重新将父类的方法再写一遍。

注意：格式与父类的一模一样，方法中的内容可以不同。

不强制要求重写。重写的情况：父类方法不能满足子类的需求，子类需要将方法进行扩展实现。父类只有一个，子类有多个，所有的子类的方法名可能一样，但实现的具体逻辑不一样。

方法重写之后，子类会调用重写之后的方法，会调用改造的方法。

子类重写的方法一般会在父类的方法上重构、修改、扩展。

不同的子类，再调用相同名字方法的时候，会执行出不一样的结果。

e.g.在子类UNStudent和MIDStudent中重写Student中定义的方法read()。

①不进行重写，直接运行。

//Student.java
public class Student {
    public void read(){
        System.out.println ("Student Read Book");
    }
}

//UNStudent.java
public class UNStudent extends Student{}

//MIDStudent.java
public class MIDStudent extends Student{}

//StuManage.java
public class StuManage{

    public static void main(String[] args){
        UNStudent unstuXZ = new UNStudent ();
        MIDStudent midstuXM = new MIDStudent ();
        unstuXZ.read ();
        midstuXM.read ();
    }

}

运行结果

Student Read Book
Student Read Book

②重写并运行。

//Student.java
public class Student {
    public void read(){
        System.out.println ("Student Read Book");
    }
}

//UNStudent.java
public class UNStudent extends Student{
    // 重写的父类的方法
    public void read(){
        System.out.println ("UNstudent Read Book");
    }
}

//MIDStudent.java
public class MIDStudent extends Student{
    public void read(){
        System.out.println ("MIDStudent Read Book");
    }
}

//StuManage.java
public class StuManage{

    public static void main(String[] args){
        UNStudent unstuXZ = new UNStudent ();
        MIDStudent midstuXM = new MIDStudent ();
        unstuXZ.read ();
        midstuXM.read ();
    }

}

运行结果

UNstudent Read Book
MIDStudent Read Book

2）接口的实现类中，重写接口中的抽象方法（没有方法体的方法）

强制要求重写接口中所有的方法。

重写时，将分号改为大括号。

e.g.在接口ActionListener的实现类LoginListener中重写方法actionPerformed(ActionEvent e)。

public interface ActionListener extends EventListener {

    /**
     * Invoked when an action occurs.
     */
    public void actionPerformed(ActionEvent e);

}

重写后的方法详见登录注册程序v2.0。

3.5 Object类

Java 中所有的类都默认继承了Object这个类，而且是隐式的。

任何类都可以重写Object这个类的方法。

任何类都可以调用Object类中不受限制的方法。

e.g.String类中重写Object类的方法equals(Object obj)。

public class Object {

    ...

    public boolean equals(Object obj) {
        return (this == obj);
    }

    ...

}

public class String{
    
    ...

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

    ...

}

3.6 转型

子类对象与父类类型之间：将子类对象转换为父类类型。

e.g.将子类UNStudent对象unstuXZ转换为父类Student类型。

//Student.java
public class Student {
    public void read(){
        System.out.println ("Student Read Book");
    }
}

//UNStudent.java
public class UNStudent extends Student{
    public void exam_CET(){
        System.out.println ("UNStudent CET ");
    }
    // 重写的父类的方法
    public void read(){
        System.out.println ("UNstudent Read Book");
    }
}

//StuManage.java
public class StuManage{
    public static void stuRead(Student stu){
        stu.read ();
    }
    public static void main(String[] args){
        UNStudent unstuXZ = new UNStudent ();
        unstuXZ.read ();
// unstu 小张
        Student stuXZ = unstuXZ;
// stuXZ.exam_CET();// 不能调用
        unstuXZ.exam_CET ();// 能不能调用考试CET 与对象变量名的类型有关系
// 学生小张 在调用重写过的方法时 依然会调用重写之后的方法
        stuXZ.read ();
// 子类对象可以说它是父类类型
// 调用学生阅读
        stuRead (stuXZ);
    }
}

运行结果