Java基础知识2

Java基础知识2

---

---

前言

一些Java的基础知识，包含：抽象类、类的高级特性、接口、代码块、匿名对象、内部类。

---

一、抽象类

是一个不能被实例化的类，只能被继承，常用于定义子类的通用行为。抽象类中可以包含抽象方法，这些方法没有具体实现，需要在子类中进行实现。在抽象类中可以包含非抽象的方法。

代码如下（示例）：

// 定义抽象类 Animal
abstract class Animal {
    String name;
    int age;

    // 抽象方法
    abstract void makeSound();

    // 具体方法
    void setName(String name) {
        this.name = name;
    }

    void setAge(int age) {
        this.age = age;
    }

    // 具体方法
    void printInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

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

// 子类 Cat 继承自抽象类 Animal
class Cat extends Animal {
    // 实现抽象方法
    void makeSound() {
        System.out.println("Meow!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("Buddy");
        dog.setAge(3);
        dog.printInfo();
        dog.makeSound(); // 调用抽象方法

        Cat cat = new Cat();
        cat.setName("Whiskers");
        cat.setAge(5);
        cat.printInfo();
        cat.makeSound(); // 调用抽象方法
    }
}

二、类的高级特性

1.abstract关键字的冲突

代码如下（示例）：

abstract final class MyClass { // 这里会产生编译错误，abstract 和 final 冲突
    // 类的定义
}
class MyClass {
    abstract private void myMethod(); // 这里会产生编译错误，abstract 和 private 冲突
}

2.static关键字的介绍

static是静态的意思，可以修饰成员变量，也可以修饰成员方法

代码如下（示例）：

public class MyClass {
    public static int count = 0; // 静态变量 count
}
public class MyClass {
    public static void myStaticMethod() {
        // 静态方法体
    }
}
public class MyClass {
    static {
        // 静态块内的代码
    }
}
public class OuterClass {
    static class StaticInnerClass {
        // 静态内部类的定义
    }
}
import static java.lang.Math.PI;
// 使用import static语句导入静态成员，允许直接访问被导入类的静态成员，无需使用类名限定符。
public class MyClass {
    double area = 2 * PI * radius; // 直接使用静态导入的 PI
}

3.final关键字的介绍

1)final修饰类不可以被继承，但是可以继承其他类。
2)final修饰的方法不可以被覆盖，但父类中没有被final修饰方法，子类覆盖后可以加final。
3)final修饰的变量称为常量，这些变量只能赋值一次。
4)引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改。
5)修饰成员变量，需要在创建对象前赋值，否则报错。

代码如下（示例）：

final int VALUE = 10; // 声明一个常量
final MyClass obj = new MyClass(); // 引用不能改变，但对象可以改变
class Parent {
    final void myMethod() {
        // 可用于方法声明，不能被子类重写的方法
    }
}
final class MyClass {
    // 不能被继承的类
}
void myMethod(final int num) {
    // 在方法参数中使用 final 关键字，表示参数在方法内部不能被修改。
}

三、接口

在Java中，接口是一种抽象类型，用于定义一组方法签名，但不包含方法的实际实现。它是一种规范，定义了类应该实现的方法。

1.基本特点

1）抽象性： 接口中的方法没有具体的实现，只有方法名、参数列表和返回类型。
2）多继承性： 一个类可以同时实现多个接口。
3）实现性： 类可以通过 implements 关键字实现接口，然后提供接口中定义的方法的实际实现。

2.接口中成员变量特点

3.代码实现

代码如下（示例）：

//接口的声明方式
public interface MyInterface {
    // 声明方法，不包含方法体
    void myMethod();

    // 声明常量，接口中的常量默认为 public static final
    int MY_CONSTANT = 10;
}

public class MyClass implements MyInterface {
    // 实现接口中的方法
    public void myMethod() {
        // 具体实现
    }
}

四、代码块

在Java中，代码块是一组Java语句的集合，可以在类中或方法中定义。主要分为以下几种类型：

1.局部代码块

用花括号 {} 括起来的一组语句。在方法中或任何作用域内都可以创建。它可以限定变量的生命周期，及早释放，提高内存利用率。

代码如下（示例）：

public void myMethod() {
    // 普通代码块
    {
        int x = 10;
        System.out.println(x);
    }
}

2.构造代码块

在类中定义的用花括号 {} 括起来的一组语句，在创建对象时被调用执行。每次创建对象时，都会执行构造块。

代码如下（示例）：

public class MyClass {
    // 构造块
    {
        // 这里面的代码在构造器调用前执行
        System.out.println("Constructor block");
    }
    
    // 构造方法
    public MyClass() {
        System.out.println("Constructor");
    }
}

3.静态代码块

使用 static 关键字定义，只在类加载时执行一次。用于初始化静态变量或执行只需要执行一次的操作。

代码如下（示例）：

public class MyClass {
    // 静态代码块
    static {
        // 这里面的代码在类加载时执行
        System.out.println("Static block");
    }
    
    // 静态方法
    public static void myStaticMethod() {
        // 静态方法
    }
}

五、匿名对象

匿名对象是指没有名字的对象，通常在创建对象时不为其分配名字。它通常用于一次性的、临时的场景，不需要在其他地方引用或复用这个对象。
匿名对象的生命周期通常在创建时即刻开始，在使用完成后立即被垃圾回收。它是一种灵活的方式。
匿名对象主要用于以下几种情况：
1.作为参数传递：
可以在方法调用时创建并直接传递匿名对象作为参数。

代码如下（示例）：

// 传递匿名对象给方法
myMethod(new MyClass()); 

2.简化代码：
在某些场景下，不需要单独创建对象，可以直接使用匿名对象。

代码如下（示例）：

// 使用匿名对象直接调用方法
new MyClass().someMethod(); 

3.临时使用：
如果对象只在某个方法或代码块中使用一次，可以使用匿名对象。

代码如下（示例）：

// 在循环中使用匿名对象
for (int i = 0; i < 5; i++) {
    new MyClass().doSomething();
}

六、内部类

内部类是定义在另一个类或代码块内部的类。

1.成员内部类

成员内部类是定义在外部类中的类。它可以直接访问外部类的所有成员，并且可以用外部类的实例来创建。

方法的声明通常遵循以下结构：

public class Outer {
    private int outerField;

    class Inner {
        void innerMethod() {
            outerField = 10; // 可以访问外部类的私有字段
        }
    }
    
    public void outerMethod() {
        Inner inner = new Inner(); // 创建内部类实例
        inner.innerMethod();
    }
}

2.静态内部类

静态内部类是被声明为静态的内部类。它与外部类的实例无关，可以直接创建静态内部类的实例。

代码如下（示例）：

public class Outer {
    private static int outerStaticField;

    static class StaticInner {
        void staticInnerMethod() {
            outerStaticField = 20; // 可以访问外部类的静态字段
        }
    }
}

3.局部内部类

局部内部类是定义在方法内部的类，只在该方法内部可见。通常用于较小的作用范围。

代码如下（示例）：

public class Outer {
    public void outerMethod() {
        class LocalInner {
            void localInnerMethod() {
                System.out.println("This is a local inner class");
            }
        }
        LocalInner localInner = new LocalInner();
        localInner.localInnerMethod();
    }
}

4.匿名内部类

匿名内部类是没有类名的内部类，通常用于创建一个类的实例并且可能重写其中的方法。

代码如下（示例）：

public class Outer {
    interface InnerInterface {
        void display();
    }

    public void outerMethod() {
        InnerInterface inner = new InnerInterface() {
            @Override
            public void display() {
                System.out.println("Anonymous inner class implementation");
            }
        };
        inner.display();
    }
}

总结

以上就是一些Java的基础知识，包含：抽象类、类的高级特性、接口、代码块、匿名对象、内部类。