Java快速入门 知识精简（5）类的成员

抽象类

抽象：既不具体，也无法具体

关键字：abstract

抽象类：范围更广，某类不同事物的描述；如：动物

具体类：某个事物的描述；如：狗，猫

说明：

1）抽象类不能创建对象实例。抽象是用来被继承的

2）具体类继承抽象类，同时需要重写抽象方法

实例

public abstract class Animal {
    // 抽象方法，没有方法体
    public abstract void makeSound();

    // 具体方法，有方法体
    public void breathe() {
        System.out.println("This animal can breathe.");
    }
}

// 子类继承抽象类并实现抽象方法
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof woof!");
    }
}

---

抽象方法：只有方法声明，没有方法体

如：

public abstract void eat( );         // 抽象方法：没有方法体

public abstract void call( );         // 抽象方法：没有方法体

---

方法

方法：java程序中独立的功能单位

语法：

修饰符 返回值类型 方法名（数据类型1 形参1 ，数据类型2 形参2 ……）{

        // 方法体：对参数中的真实数据进行加工和处理

        return 返回值；

}

说明：

传递方式：值传递  形参=实参

返回值类型：方法的成果数据的类型

形参：形式参数，形式上的一个参数

实参：方法在被调用时，由调用者给定的实际参数

方法 = 方法签名（方法的使用说明书API）+方法体（真正执行的东西）

方法不可以嵌套，只能并列存在

方法的返回值：

调用方法本身

实例：

public int add ( int a , int b ){

        int c = a+b;

        return c;

 }

// 调用：变量 = 方法调用（）；

public void main( String[] args ){

        int x = add ( 10 , 30 );

        System.out.println ( x );

}

说明

方法	说明
void method ( );	无参数; 无返回值
void method ( int a );	有参数int类型的a; 无返回值
int method ( );	无参数; 有返回值int类型
int add ( int a ; int b ) ;	有参数int类型a,int类型b; 有返回值int类型

方法的重载：overload

用途：相似功能的方法时可以用到方法的重载

1）方法名相同

2）参数列表不同既可，与修饰符和返回值无关

3）参数列表：数据类型不同，参数个数不同，顺序不同

方法的递归：

1）方法自己调用自己

2）作用：把一个复杂的问题分解成简单化的问题，分解相同类型的子问题

说明：

当递归时程序没有结束条件，一定会发生栈内存溢出错误：StackOverflowError

所以：递归必须要有结束条件。（这是一个非常重要的知识点。）

递归结束：

// 计算n的阶层：5! = n*4!

public int test(int n){

    // return n*test(n-1);  无限递归：错误方式

    if (n==1){    // 递归结束条件

        return 1;

    }

    return n*test(n-1);

}

递归与循环的区别：

      递归：告诉计算机做什么

      循环：告诉计算机怎么做

接口

接口：interface

接口：用于表达某种能力，接口的词性通常是形容词，用于表达标准或规范。

不同类不同种事物共同行为的抽象

示例：

      鸟和飞机可以定义为具体的类；

      它们的共同行为特征可以定义为接口：比如：飞行

接口：public interface Fly{   }

说明：

1）接口中的所有方法都是抽象的方法：abstract

2）接口中的所有方法都是公共的方法：public

3）接口中的所有属性必须是全局常量。

4）接口中没有构造器。

实现：implements

class Birds implements Fly{

    @Override        // 注解: 重写了接口中的方法
    public void connect() {
                // 语句;
    }

    @Override
    public void work() {
                // 语句;
    }
}

说明：

1）接口不能继承类，类也不能继承接口

2）唯一关系：类实现接口

3）一个类可以实现多个接口

内部类

提供了一种新的封装和组织代码的方式

分类：按声明位置：

1）成员内部类：声明在类中方法外

      普通内部类：没有static修饰

      静态内部类：有static修饰

2）局部内部类：声明在方法中

            普通内部类：更夸张的对象关联

            匿名内部类：

示例

// 内部类示例
public class OuterClass {

    // 成员内部类
    class InnerClass {
        void display() {
            System.out.println("我是成员内部类");
        }
    }

    // 静态内部类()
    static class StaticInnerClass {
        void display() {
            System.out.println("我是静态内部类");
        }
    }


    void outerMethod() {
        // 局部内部类
        class LocalInnerClass {
            void show() {
                System.out.println("我是局部内部类");
            }
        }
        LocalInnerClass lic = new LocalInnerClass();
        lic.show();
    }

    // 匿名内部类
    // 实现一个接口
    (new Runnable() {
        public void run() {
            System.out.println("Running an anonymous inner class");
        }
    }).run();

    // 继承一个类
    (new Thread(new Runnable() {
        public void run() {
            System.out.println("Thread running");
        }
    })).start();
}

匿名内部类

new 父类构造器（实参列表）{

        // 内容：一定是具体子类，多用于与接口配合使用

 };

1）不能定义为static静态的

2）一定是单例模式：只能new一次

调用

用多态调用 ：

Other other = new Other( ){         

            // 类体  ，适用于接口实现子类对象的一次性使用

};

说明：内部类与外部类的分隔符：Other$Inner

创建内部类对象：需要加限定

other.new Inner( );

Other other2 = new Other( );

other2.new Inner( );

枚举类

枚举enum : 用来表示固定数量的常量

1）不能将不是枚举类型常量值的任何其他值赋给枚举变量

2）枚举常量可以有自己的方法和字段，这使得枚举类型可以拥有行为

3）枚举类型可以有构造函数，但构造函数不能被外部代码显式调用，只能由枚举本身调用

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;

    public void printDay() {
        System.out.println("Today is " + this.name());
    }
}

public class TestEnum {
    public static void main(String[] args) {
        for (Day day : Day.values()) {
            day.printDay();
        }

        // 使用 switch 语句
        Day day = Day.MONDAY;
        switch (day) {
            case MONDAY:
                System.out.println("Mondays are bad.");
                break;
            case FRIDAY:
                System.out.println("Fridays are better.");
                break;
            default:
                System.out.println("The weekend is coming!");
        }
    }
}

---

注解类

注解（Annotation）是一种特殊的接口，用于为代码元素（如类、方法、变量等）提供元数据

在注解接口中定义元素，这些元素可以是方法、字段等

示例

// 定义一个注解，用于标记过时的方法
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME) // 保留到运行时
@Target(ElementType.METHOD) // 只用于方法
public @interface DeprecatedMethod {
    String value() default "No reason";
}

// 使用注解
public class Example {

    @DeprecatedMethod(value = "This method is no longer supported.")
    public void oldMethod() {
        // 旧方法的实现
    }

    public void newMethod() {
        // 新方法的实现
    }
}

说明：

1）使用 @interface 关键字定义注解

2）使用 @Retention 注解来指定注解的保留时间，可以是 SOURCE、CLASS 或 RUNTIME

3）使用 @Target 注解来指定注解可以应用于哪些元素上，如 TYPE（类、接口）、METHOD、FIELD、PARAMETER 等

4）在注解接口中定义元素，这些元素可以是方法、字段等