JAVA 类与接口详解-优快云博客

本文详细介绍了JAVA中的类与接口基础，包括类的定义、继承、多态，接口的定义、继承、实现及其多态性。讲解了类的源文件申明规则、访问修饰符，以及静态与普通成员变量/函数的区别。同时，解释了接口如何作为类的扩展，以及接口继承和实现的特性。

JAVA 类与接口基础

Acwing Java语法基础笔记

1.类与对象

类，是一个模板，描述一类对象的行为和状态，定义一种全新的数据类型，包含一组变量和函数；

对象，是类这种类型对应的实例。对象是根据类创建的，使用关键字 new 创建对象。

1.1 源文件申明规则

在一个源文件中定义多个类，并且还有import语句和package语句时：

一个源文件中只能有一个 public 类
一个源文件可以有多个非 public 类
源文件的名称应该和public类的类名保持一致。（源文件public类的类名是 Dog，则源文件名应为：Dog.java）
每个源文件中，先写package语句，再写import语句，最后定义类

1.2 类的定义

[修饰符] class 类名 [extends 父类名] [implements 接口名]{
    
  // 类体，包括类的成员变量和成员方法
    
 }
//修饰符：private,public,protected

public : 所有对象均可以访问
private : 只有本类内部可以访问（不能用来修饰类）
protected：同一个包或者子类中可以访问（不能用来修饰类）
不添加修饰符：在同一个包中可以访问
静态（带static修饰符）成员变量/函数与普通成员变量/函数的区别：
- 所有static成员变量/函数在类中只有一份，被所有类的对象共享；无论一个类实例化多少对象，它的静态变量只有一份拷贝。
- 所有普通成员变量/函数在类的每个对象中都有独立的一份；
- 静态函数中只能调用静态函数/变量；普通函数中既可以调用普通数/变量，也可以调用静态函数/变量。

class Point {
    private int x;
    private int y;
    public Point(int x, int y) {
        //this 是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。
        this.x = x;
        this.y = y;
    }
    public void setX(int x) {
        this.x = x;
    }
    public void setY(int y) {
        this.y = y;
    }
    public int getX() {
        return x;
    }
    public int getY() {
        return y;
    }
    public String toString() {
        return String.format("(%d, %d)", x, y);
    }
}

1.3 类的继承

每个类只能继承一个类。（一个子类只能继承一个父类）

子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展（extends）。
子类可以用自己的方式实现父类的方法（函数）。

class ColorPoint extends Point {
    private String color;

    public ColorPoint(int x, int y, String color) {
        //super 相当于是指向当前对象的父类，这样就可以用 super.xxx 来引用父类的成员。
        super(x, y); //super(参数)：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。另外，调用super()必须写在子类构造方法的第一行，否则编译不通过
        this.color = color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String toString() {
        return String.format("(%d, %d, %s)", super.getX(), super.getY(), this.color);
    }
}

1.4 类的多态

多态是同一个行为具有多个不同表现形式或形态的能力。通俗讲就是父类和子类都具有某一个相同的函数，而实例在调用该函数时表现形式（输出）不同。

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

public class Main {
    public static void main(String[] args) {
        Point point = new Point(3, 4);
        Point colorPoint = new ColorPoint(1, 2, "red");

        // 多态，同一个类的实例，调用相同的函数，运行结果不同
        System.out.println(point.toString());
        System.out.println(colorPoint.toString());
    }
}

2.接口

interface与class类似。主要用来定义类中所需包含的函数。

接口也可以继承其他接口，一个类可以实现多个接口。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口不能用于实例化对象。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。子接口可以继承多个父接口（类不可以多继承）

2.1 接口的定义

接口中不添加修饰符时，默认为public。

interface Role {
    public void greet();
    public void move();
    public int getSpeed();
}

2.2 接口的继承

每个接口可以继承多个接口

interface Hero extends Role {
    public void attack();
}

2.3 接口的实现

每个类可以实现多个接口

class Zeus implements Hero {
    private final String name = "Zeus";
    public void attack() {
        System.out.println(name + ": Attack!");
    }

    public void greet() {
        System.out.println(name + ": Hi!");
    }

    public void move() {
        System.out.println(name + ": Move!");
    }

    public int getSpeed() {
        return 10;
    }
}

2.4 接口的多态

class Athena implements Hero {
    private final String name = "Athena";
    public void attack() {
        System.out.println(name + ": Attack!!!");
    }

    public void greet() {
        System.out.println(name + ": Hi!!!");
    }

    public void move() {
        System.out.println(name + ": Move!!!");
    }

    public int getSpeed() {
        return 10;
    }
}

public class Main {
    public static void main(String[] args) {
        //接口不可以实例化，用接口实现的类可实例化
        Hero[] heros = {new Zeus(), new Athena()};//声明变量是以该接口实现的
        for (Hero hero: heros) {
            hero.greet();
        }
    }
}

拓展：

自定义的对象数组需要排序时，需借助Arrays.sort()，此时自定义对象需要继承Comparable接口，并重写compareTo方法：

import java.util.Scanner;
import java.util.Arrays;

// 点的结构（int,double），输出按照int排序的结果
class Point implements Comparable<Point> 
//自定义对象同样需要继承Comparable接口，并重写compareTo方法
{
    int x;
    double y;
    public Point(int x,double y)
    {
        this.x=x;
        this.y=y;
    }
    public int compareTo(Point t) //重写compareTo，大于返回正数，等于返回0，小于返回负数。
    {
        return x-t.x;
    }
}
public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        Point[] points = new Point[n];
        for(int i=0;i<n;i++)
        {
            int x=sc.nextInt();
            double y=sc.nextDouble();
            points[i]= new Point(x,y);
        }
        
        Arrays.sort(points);
        for(int i=0;i<n;i++)
            System.out.printf("%d %.2f\n",points[i].x,points[i].y);
    }
}