Java面向对象高级

ber official

已于 2023-09-23 23:11:40 修改

阅读量173

点赞数 3

分类专栏： JavaSE学习文章标签： java 开发语言

于 2023-09-04 17:37:10 首次发布

本文链接：https://blog.csdn.net/m0_73059696/article/details/132672924

版权

JavaSE学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、static 关键字

1. static 修饰成员变量

1）类变量：有 static 修饰，属于类，在计算机里只有一份，会被类的全部对象共享。

2）实例变量(对象的变量)：无 static 修饰，属于对象。

public class CLASS {
    static String name;
    int age;
}

public class Test {
    public static void main(String[] args) {
        // 类名.类变量
        CLASS.name = "wyb";
        // 对象名.实例变量
        CLASS c = new CLASS();
        c.age = 13;
    }
}

2. static 修饰成员方法

1）类方法：有 static 修饰，属于类。

2）实例方法(对象的方法)：无 static 修饰，属于对象。

补充：main 方法

main 方法也属于一种类方法，它也可以传入参数。

在程序执行时，JVM虚拟机会直接调用 main 方法。

3. static 的注意事项

1）类方法中可以直接访问类的成员，不可以直接访问实例成员。

2）实例方法中既可以直接访问类成员，也可以直接访问实例成员。

3）实例方法中可以出现 this 关键字，类方法中不可以出现 this 关键字的。

（ this 是用来指向调用方法的对象，而类方法只针对类）

4.代码块

代码块是类的5大成分之一（成员变量，成员方法，构造器，代码块，内部类）

1）静态代码块

格式：static { }

特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。

作用：完成类的初始化，例如对类变量的初始化赋值。

public class CLASS {
    static String name;
    static int age;
    static {
        name = "wyb";
        age = 20;
    }
}
public class Test {
    public static void main(String[] args) {
        System.out.println(CLASS.name);
        System.out.println(CLASS.age);
    }
}

2）实例代码块

格式：{ }

特点：每次创建对象时，执行实例代码块，并在构造器前执行。

作用：和构造器一样，都是用来完成对象的初始化的，例如对实例变量进行初始化赋值。

5.单例设计模式

作用：确保一个类只有一个对象

（1）饿汉式单例（创建类时创建对象）

方法：1）把类的构造器私有（为了使外部无法创建对象）

2）定义一个类变量，记住类的对象

3）定义一个类方法，返回对象

public class CLASS {
    private static CLASS student = new CLASS();
    private CLASS() {}
    public static CLASS getStudent()
    {
        return student;
    }
}

（2）懒汉式单例（需要对象时创建对象）

方法：1）把类的构造器私有（为了使外部无法创建对象）

2）定义一个类变量用于存储类的对象

3）定义一个类方法，第一次调用时创建对象，再返回对象

public class CLASS {
    private static CLASS student;
    private CLASS() {}
    public static CLASS getStudent()
    {
        if(student == null)
        {
            student = new CLASS();
        }
        return student;
    }
}

二、继承

1.继承的基本使用

定义：利用 extends 关键字，使一个类和另一个类建立父子关系

特点：子类能够继承父类的非私有成员变量和成员方法

对象的创建：由子类和父类共同完成

public class A {
    public int a;
    public void print1()
    {
        System.out.println("--public print--");
    }
    private int b;
    private void print2()
    {
        System.out.println("--private print--");
    }
}
public class B extends A{
    public int b;
    public void print3()
    {
        System.out.println(a);
        print1();

        //System.out.println(b);
        //print2();
    }
}
public class Test {
    public static void main(String[] args) {
        B b = new B();

        System.out.println(b.a);
        //System.out.println(b.b);
        b.print1();
        //b.print2();
        b.print3();
    }
}

2.权限修饰符

作用：限制类中的成员能够被访问的范围

分类：public private protected 【缺省】

3.单继承

Java只有单继承，不支持多继承，但可以多层继承

例：A => B => C C可以继承A和B的非私有成员

public class A {
    public int i;
    public void print1()
    {
        System.out.println("--public print--");
    }
    private int j;
    private void print2()
    {
        System.out.println("--private print--");
    }
}
public class B extends A{
    public int k;
    public void print3()
    {
        System.out.println(a);
        print1();

        //System.out.println(b);
        //print2();
    }
}
public class C extends B{
    public void print4()
    {
        System.out.println(i);
        //System.out.println(j);
        System.out.println(k);
    }
}
public class Test {
    public static void main(String[] args) {
        C c = new C();
        c.print1();
        //c.print2();
        c.print3();
        c.print4();
    }
}

4. Object 类

Object 类是Java中所有类的祖类，Object 类不需要在创建类时声明（默认继承）

Object 类的常用方法有：hascode，toString

1）toString

能够返回对象的地址，在打印对象本体时默认调用，一般用于重写 toString 方法后返回对象内容

5.方法重写

作用：当父类方法需求不能满足子类时，子类可以重写一个与父类方法名称和参数列表相同的方法

注意事项：1）重写之后，方法的访问遵循就近原则

2）重写小技巧: 使用 @Override 注解，他可以指定 java 编译器，检查我们方法重写的格式是否正确，代码可读性也会更好。

3）子类重写父类方法时，访问权限必须大于或者等于父类该方法的权限。

4）重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。

5）私有方法、静态方法不能被重写，如果重写会报错的。

public class A {
    public int i;
    public void print()
    {
        System.out.println("666");
    }

    public void func(int a,int b)
    {
        System.out.println(a+b);
    }
}

public class B extends A{
    @Override
    public void print()
    {
        System.out.println("abc");
    }
    @Override
    public void func(int a,int b)
    {
        System.out.println(a-b);

    }
}

应用：重写 Object 类的 toString 方法

6.子类的成员访问特点

1）就近原则

2）访问本类成员用this，访问父类成员用super

7.子类构造器

特点：调用子类构造器前，会先调用父类的无参构造器，在执行自己，即在创建子类构造器时默认包含了 super()

class X{
    public X() {
        System.out.println("1");
    }
}
class Y extends X{
    public Y() {
        //super(); 子类构造器默认存在
        System.out.println("2");
    }
    public Y(int a) {
        //super(); 子类构造器默认存在
        System.out.println("3");
    }
}

注意：1）如果父类没有无参构造器，程序会出错，可以手动书写 super() 函数；

2）如果想要调用父类的有参构造器，一定要创建同参子类构造器并声明super()

3）super() 只能在构造器第一行声明

8. this() 调用兄弟构造器

class Student{
    public Student(){
    }
    public Student(String name,int age)
    {
        this(name,age,60);
    }
    public Student(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    public String name;
    public int age;
    public int score;
}

注意：同 super() 一样，this() 也只能在构造器第一行声明，并且这两者不能同时在一个构造器里声明

三、多态

1.认识多态

Java中分为对象多态和行为多态，但是属性（成员变量）无多态

必须有相对的继承关系才能实现多态操作，并且子类要求对父类的方法重写

class People{
    public String name = "People";
    public void showClass(){
        System.out.println("People方法");
    }
}
class Teacher extends People{
    public String name = "Teacher";
    public void showClass(){
        System.out.println("Teacher方法");
    }
}
class Student extends People{
    public String name = "Student";
    public void showClass(){
        System.out.println("Student方法");
    }
}
public class Test {
    public static void main(String[] args) {
        People p1 = new Teacher();  // 对象多态
        System.out.println(p1.name);// 成员变量无多态
        p1.showClass();             // 行为多态

        People p2 = new Student();
        System.out.println(p2.name);// 编译看左边，运行也看左边
        p2.showClass();             // 编译看左边，运行看右边
    }
}

注意：编译时只能调用父类的成员方法，但运行时执行的是子类重写后的成员方法

2.多态的优点

1）在多态的形式下，new的对象是解耦合的

//People p = new Teachar();
People p = new Student();

new 创建的对象类型随时可以改变

2）方法在调用对象时，只需要通过父类的对象类型接收，即可接收所有多态形式下的子类对象

public class Test {
    public static void main(String[] args) {
        People p1 = new Teacher();
        People p2 = new Student();
        printName(p1);
        printName(p2);
    }
    public static void printName(People p){
        System.out.println(p.getName());
    }
}

3.多态的缺点

在多态形式下，无法访问子类独有的成员方法

解决方案：强制类型转换（只能转换相对应的子类类型）

public class Test {
    public static void main(String[] args) {
        People p1 = new Teacher();
        Teacher t1 = (Teacher) p1;
        People p2 = new Student();
        Teacher t2 = (Teacher) p2;
    }
}

代码如上，p1 完成了类型转换，但 p2 报错

补充：instanceof 关键字，用于判断对象类型是否对应

        People p1 = new Teacher();
        if(p1 instanceof Teacher) {
            Teacher t1 = (Teacher) p1;
        }
        else {
            Student s1 = (Student) p1;
        }

四、补充

1. final 关键字

修饰类：该类被称为最终类，特点是不能被继承了。

修饰方法：该方法被称为最终方法，特点是不能被重写了。

修饰变量：该变量有且只能赋值一次。

public class Test {
    // final修饰静态成员变量 -> 常量
    public static final String S_NAME = "cxk";
    // final修饰实例成员变量
    private final int age = 11;
    
    public static void main(String[] args) {
        // final修饰基本类型变量
        final String name = "fzc";
        // final修饰引用类型变量
        final int[] arr = {1,2,3};
    }
}

注意：1）final修饰的静态成员变量即为常量

2）final修饰基本类型的变量，该变量的值不可改变

3）final修饰引用类型的变量，该变量的地址不可改变

2.常量

使用 static final 修饰的成员变量即为常量

作用：通常用于记录系统的配置信息

命名规范：单词全部大写，单词与单词之间用_连接

优点：1）代码可读性更好，可维护性也更好。

2）程序编译后，常量会被“宏替换”：出现常量的地方全部会被替换成其记住的字面量，这样可以保证使用常量和直接用字面量的性能是一样的。

五、抽象类

1.认识抽象类

1）abstract 关键字：用于修饰类和成员方法

abstract class People{
    public abstract void fun();
}

注意：修饰的成员方法不能有方法体

2.抽象类的特点

1）抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。

2）类该有的成员(成员变量、方法、构造器)抽象类都可以有。

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

4）一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

3.使用抽象类的好处

最大的优势在于能够更好地支持多态

class Teacher extends People{
    public Teacher(String name) {
        super(name);
    }
    @Override
    public void action() {
        System.out.println("老师在教书");
    }
}
class Student extends People{
    public Student(String name) {
        super(name);
    }
    @Override
    public void action() {
        System.out.println("学生在学习");
    }
}
abstract class People{
    private String name;
    public People(String name) {
        this.name = name;
    }
    public void printName() {
        System.out.print(name);
    }
    public abstract void action();
}
public class Test {
    public static void main(String[] args) {
        People p1 = new Student("fzc");
        p1.printName();
        p1.action();
        People p2 = new Teacher("cxk");
        p2.printName();
        p2.action();
    }
}

上述代码为 People 父类下，Student 和 Teacher 两个子类对象，通过抽象方法重写，来创建对象

4.应用场景：模版方法设计模式

用于解决大量的重复代码

1）定义一个抽象类。

2）在里面定义2种方法：模板方法 -- 把相同代码放里面去。

抽象方法 -- 具体实现交给子类完成。

上一小节的代码就已经体现出来了这种设计模式，这里不再举例

注意：如果模版方法不再修改，建议用 final 修饰

六、接口

1.认识接口

1）interface 关键字：用于定义接口

interface People{
    // 默认为常量，不需要static final修饰
    String NAME = "cxk";
    // 默认为抽象方法，不需要abstract修饰
    void action();
}

接口中只能定义成员变量（常量）和成员方法（抽象方法），且不能直接创建对象

功能：用来被类实现（implements），实现接口的类叫做实现类

public interface A {
    void testA1();
    void testA2();
}
public interface B {
    void testB1();
    void testB2();
}
// 实现类
public class C implements A,B{
    @Override
    public void testA1() {}
    @Override
    public void testA2() {}
    @Override
    public void testB1() {}
    @Override
    public void testB2() {}
}

注意：一个类可以实现多个接口，但必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类。

2.接口的好处

1）弥补了类单继承的不足，一个类在继承其他类的同时，也可以实现多个接口。

2）让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现。

3.接口综合案例

1）创建一个 Student 类，用于存储单个学生的信息

public class Student {
    private String name;
    private String sex;
    private double score;
    public Student() {
    }
    public Student(String name, String sex, double score) {
        this.name = name;
        this.sex = sex;
        this.score = score;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }
}

包含三种属性，对应的 get,set 方法和用于初始化的构造器

2）创建一个 ClassManager 类，用于存储全部学生信息和实现题目需求的操作

public class ClassManager {
    private ArrayList<Student> students = new ArrayList<>();
    public ClassManager() {
        students.add(new Student("A","男",100));
        students.add(new Student("B","女",60));
        students.add(new Student("C","女",77));
        students.add(new Student("D","男",88));
    }
    public void printInfo(){
    }
    public void printScore(){
    }
}

使用 ArrayList 集合存储学生信息，利用构造器初始化，初步定义两个实现功能的方法

3）因为两种功能各有两种方案，所以利用面向接口编程思想，通过接口创建实现类

public interface StudentOperator {
    void printInfo(ArrayList<Student> students);
    void printScore(ArrayList<Student> students);
}

4）创建两个实现类

public class StudentOperatormpl1 implements StudentOperator{
    @Override
    public void printInfo(ArrayList<Student> students) {
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            System.out.println("姓名："+s.getName()+" 性别："+s.getSex()+" 分数："+s.getScore());
        }
    }
    @Override
    public void printScore(ArrayList<Student> students) {
        double allsroce = 0;
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            allsroce += s.getScore();
        }
        System.out.println("平均分为："+allsroce/students.size());
    }
}

public class StudentOperatormpl2 implements StudentOperator{
    @Override
    public void printInfo(ArrayList<Student> students) {
        int manCount = 0,womanCount = 0;
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            System.out.println("姓名："+s.getName()+" 性别："+s.getSex()+" 分数："+s.getScore());
            if(s.getSex().equals("男")){
                manCount += 1;
            }
            else{
                womanCount += 1;
            }
        }
        System.out.println("男生人数为："+manCount+"女生人数为"+womanCount);
    }
    @Override
    public void printScore(ArrayList<Student> students) {
        double allsroce = 0,max = 0,min = 100;
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            allsroce += s.getScore();
            max = max>s.getScore()?max:s.getScore();
            min = min<s.getScore()?min:s.getScore();
        }
        double aveScore = (allsroce-max-min)/(students.size()-2);
        System.out.println("平均分为："+aveScore);
    }
}

5）在 ClassManager 类下调用实现类的功能

public class ClassManager {
    private ArrayList<Student> students = new ArrayList<>();
    //private StudentOperator studentOperator = new StudentOperatormpl1();
    private StudentOperator studentOperator = new StudentOperatormpl2();
    public ClassManager() {
        students.add(new Student("A","男",100));
        students.add(new Student("B","女",60));
        students.add(new Student("C","女",77));
        students.add(new Student("D","男",88));
    }
    public void printInfo(){
        studentOperator.printInfo(students);
    }
    public void printScore(){
        studentOperator.printScore(students);
    }
}

6）进行测试

public class Test {
    public static void main(String[] args) {
        ClassManager cs = new ClassManager();
        cs.printInfo();
        cs.printScore();
    }
}

补充：步骤五的实现利用了接口的多态创建实现类的对象

private StudentOperator studentOperator = new StudentOperatormpl2();

注意：接口不能直接利用接口名创建对象，但可以通过多态的形式，利用实现类来创建对象

4.接口新增方法（JDK8之后）

1）默认方法（实例方法）：使用 default 修饰，默认被 public 修饰，只能使用接口的实现类来调用

2）私有方法：必须使用 private 修饰，用于被接口中其他方法调用

3）接口方法（静态方法）：使用 static 修饰，默认被 public 修饰，可以直接通过接口调用

public interface A {
    default void test1() {
        test2();
    }
    private void test2(){

    }
    static void test3(){

    }
}

5.接口的继承（多继承）

Java中接口可以继承，并且可以多继承

interface A{
    void test1();
}
interface B{
    void test2();
}
interface C extends B,A{
    
}
class D implements C{
    @Override
    public void test1() {
    }
    @Override
    public void test2() {
    }
}

注意事项：

1）一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承。

2）一个类实现多个接口，如果多个接口中存在方法签名冲突，则此时不支持多实现。

3）一个类继承了父类，又同时实现了接口，父类中和接口中有同名的默认方法，实现类会优先用父类的。

4）一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。

七、内部类

是类中的五大成分之一（成员变量、方法、构造器、内部类、代码块）

定义：如果一个类定义在另一个类的内部，这个类就是内部类。

应用场景：当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。

1.成员内部类【了解】

将内部类视为外部类的一个成员，内部类可以随意调用外部类的成员，外部类也可以创建内部类对象来访问内部类

public class Test {
    public static void main(String[] args) {
        Outer o1 = new Outer();
        o1.test1();
        Outer.Inner o2 = new Outer().new Inner();
        o2.test2();
    }
}
class Outer{
    private int a = 100;
    public void test1() {
        Inner i1 = new Inner();
        i1.test2();
    }
    public class Inner{
        private int a = 90;
        public void test2(){
            int a = 80;
            System.out.println(a);
            System.out.println(this.a);
            System.out.println(Outer.this.a);
        }
    }
}

注意：1）在外部类的外部创建内部类对象，要下面这种形式：

Outer.Inner o2 = new Outer().new Inner();

2）如果外部类、内部类、内部类方法定义的变量重名，要逐级访问，如下：

System.out.println(a);
System.out.println(this.a);
System.out.println(Outer.this.a);

2.静态内部类【了解】

public class Test {
    public static void main(String[] args) {
        Outer.Inner o2 = new Outer.Inner();
        o2.test2();
    }
}
class Outer{
    private int a = 100;
    public static int b = 10;
    public static class Inner{
        public void test2(){
            //System.out.println(a);
            System.out.println(b);
        }
    }
}

注意：1）静态内部类可以直接访问外部类的静态变量，但不可以直接访问实例变量

2）静态内部类创建对象不需要以外部类的对象为基础来创建了

        Outer.Inner o2 = new Outer.Inner();

3.局部内部类【了解】

定义在方法，代码块，构造器中的内部类（目前不需要学）

4.匿名内部类【重点】

1）匿名内部类：用于直接创建一个对象的临时类，一般配合抽象类和接口使用

public class Test {
    public static void main(String[] args) {
        People t = new People() {
            @Override
            public void action() {
                System.out.println("老师在教书");
            }
        };
        t.action();
    }
}
abstract class People{
    public String name;
    public abstract void action();
}

注意：创建匿名内部类时，Java首先会编译出来一个子类，根据这个子类来直接创建一个对象

2）匿名内部类的应用场景

通常作为一个参数传输给方法

八、枚举

1.认识枚举

枚举是一个特殊的类

public enum A {
    X,Y,Z;
    public String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public class Test {
    public static void main(String[] args) {
        // A a = new A();
        A a1 = A.X;
        System.out.println(a1);// 可以直接打印枚举常量名

        A a2 = A.Y;
        a2.setName("cxk");
        System.out.println(a2.getName());

        A[] as = A.values(); // 将枚举类的所有常量存储到一个数组中
        A a3 = A.valueOf("Z"); // 利用对应的常量名获取常量
        System.out.println(a3.name()); // 获取对应的常量名
        System.out.println(a3.ordinal()); // 获取对应的索引
    }
}

根据上述代码，枚举类有以下特点：

1）枚举类的第一行只能罗列一些名称，这些名称都是常量，并且每个常量记住的都是枚举类的一个对象。

2）枚举类的构造器都是私有的(写不写都只能是私有的)，因此,枚举类对外不能创建对象。

3）枚举都是最终类，不可以被继承。

4）枚举类中，从第二行开始，可以定义类的其他各种成员。

5）编译器为枚举类新增了几个方法，并且枚举类都是继承：java.lang.Enum类的，从enum类也会继承到一些方法。

2.抽象枚举

在枚举中定义抽象方法

public enum A {
    X("cxk"){
        @Override
        public void showName() {
            System.out.println(getName());
        }
    },
    Y("fzc"){
        @Override
        public void showName() {
            System.out.println(getName());
        }
    };
    A() {
    }
    A(String name){
        this.name = name;
    }
    public abstract void showName();
    public String name;
    public String getName() {
        return name;
    }
}

注意：定义抽象枚举时，必须对常量对象进行方法重写

3.常见的应用场景

常用于表示一组信息，对功能进行标记和分类

例：以男女分类，创建不同的功能

enum Constant{
    BOY,GIRL;
}

public class Test {
    public static void main(String[] args) {
        check(Constant.BOY);
        check(Constant.GIRL);
    }
    public static void check(Constant sex) {
        switch (sex)
        {
            case BOY:
                System.out.println("看美女~~");
                break;
            case GIRL:
                System.out.println("看帅哥~~");
                break;
        }
    }
}

九、泛型

1.认识泛型

在定义类、接口、方法时，同时声明了一个或者多个类型变量(如：<E>) ，称为泛型类、泛型接口、泛型方法，它们统称为泛型。

作用：泛型提供了在编译阶段约束所能操作的数据类型，并自动进行检查的能力。这样可以避免强制类型转换，及其可能出现的异常。

泛型的本质：把具体的数据类型作为参数传给类型变量。

2.泛型类

public class Test {
    public static void main(String[] args) {
        myArrayList arrayList1 = new myArrayList();
        myArrayList<String> arrayList2 = new myArrayList<>();
    }
}

class myArrayList<E>{
    private Object[] arr = new Object[10];
    private int size;
    public boolean add(E e){
        arr[size++] = e;
        return true;
    }
    public E get(int index) {
        return (E)arr[index];
    }
}

注意：1）泛型类可以声明多个泛型

class myClass1<E,T,K>{
}

2）泛型类声明泛型时可以添加限制条件

class myClass2<E extends myClass1>{
}

3.泛型接口

和泛型类使用大同小异

class People{
}
class Teacher extends People{
}
interface PeopleData<E extends People>{
    void add(E e);
    String getName(E e);
}
class TeacherData implements PeopleData<Teacher>{
    @Override
    public void add(Teacher teacher) {
    }
    @Override
    public String getName(Teacher teacher) {
        return null;
    }
}

注意：泛型接口也可以声明多个泛型，也可以加限制条件

4.泛型方法

class Car{
}
class BWM extends Car{
}
class BENZ extends Car{
}

    public static<E extends Car> void test(ArrayList<E> e){
    }

泛型方法也可以声明多个泛型，也可以加限制条件

补充：

1）？通配符：用于代表泛型，可以替代一切类型

上面的代码也可以改成以下形式：

public static void test(ArrayList<? extends Car> e){
}

2）泛型上下限

? extends Car 即为上限，接收的是 Car 类及其子类

? super Car 即为下限，接收的是 Car 类及其父类

5.泛型的注意事项

1）泛型是工作在编译阶段的，一旦程序编译成class文件， class文件中就不存在泛型了，这就是泛型擦除。

2）泛型不支持基本数据类型，只能支持对象类型(引用数据类型)。