Java中难理解的四个概念

下面是讲解Java中难理解的四个概念的攻略。

下面是讲解Java中难理解的四个概念的攻略。

1. 非静态内部类和静态内部类

对于Java中的内部类，可以分为两种类型：非静态内部类和静态内部类。

非静态内部类的创建需要依赖于外部类的实例，而静态内部类则不需要。简单来说，非静态内部类可以访问外部类的非静态成员和方法，而且可以直接访问外部类的实例变量。静态内部类则不能直接访问外部类的实例变量和非静态成员，但可以访问外部类的静态成员和方法。

以下是示例代码：

public class OuterClass {
    private static String staticField = "staticField";
    private String field = "field";

    public static class StaticInnerClass {
        public void print() {
            System.out.println(staticField);
        }
    }

    public class NonStaticInnerClass {
        public void print() {
            System.out.println(field);
        }
    }

    public static void main(String[] args) {
        StaticInnerClass staticInner = new StaticInnerClass();
        staticInner.print();

        OuterClass outer = new OuterClass();
        NonStaticInnerClass nonStaticInner = outer.new NonStaticInnerClass();
        nonStaticInner.print();
    }
}

在这个例子中，StaticInnerClass是内部类的实例化不需要外部类的实例，因为静态变量可以在外部类之外被访问；而NonStaticInnerClass是内部类的实例化需要外部类实例的引用。

2. instanceof运算符

Java中的instanceof运算符用于判断一个对象是否为某个类或其子类的实例。具体的用法如下：

if (obj instanceof SomeClass) {
    // do something
}

其中obj为对象的引用，SomeClass为类或接口的名称。instanceof运算符返回true或false，用于判断obj是否为SomeClass类或其子类的实例。

以下是示例代码：

public interface InterfaceA {}

public class SubClass implements InterfaceA {}

public class Main {
    public static void main(String[] args) {
        Object obj1 = new SubClass();
        if (obj1 instanceof SubClass) {
            System.out.println("obj1 is an instance of SubClass");
        }
        if (obj1 instanceof InterfaceA) {
            System.out.println("obj1 is an instance of InterfaceA");
        }

        Object obj2 = new Object();
        if (obj2 instanceof SubClass) {
            System.out.println("obj2 is an instance of SubClass");
        }
    }
}

在这个例子中，使用instanceof运算符来判断obj1是否为SubClass类或InterfaceA接口的实例，结果都是true。而obj2不是SubClass类或其子类的实例，所以判断结果为false。

3. 重载和重写

重载（Overload）和重写（Override）是Java面向对象编程中的两个常用概念。

重载指的是在一个类中定义多个同名的方法，但参数类型、个数或顺序不同。不同的方法根据传递参数的不同而调用不同的方法。重载的方法可以拥有不同的返回类型，但是不能只有返回类型不同。

以下是示例代码：

public class Overload {
    public static int add(int a, int b) {
        return a + b;
    }

    public static double add(double a, double b, double c) {
        return a + b + c;
    }

    public static void main(String[] args) {
        System.out.println(add(1, 2));
        System.out.println(add(1.2, 2.3, 3.4));
    }
}

在这个例子中，定义了两个同名的方法add，但它们的参数类型、个数和顺序不同。在main方法中分别调用了这两个方法，并根据传递参数的不同而调用不同的方法。

重写指的是子类改写父类中的方法，方法名、参数和返回类型都应该和父类中要重写的方法一致。通过重写，子类可以实现自己的业务逻辑。

以下是示例代码：

public class Animal {
    public void move() {
        System.out.println("Animal can move...");
    }
}

public class Dog extends Animal {
    @Override
    public void move() {
        System.out.println("Dog can run and bark...");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.move();

        Dog dog = new Dog();
        dog.move();
    }
}

在这个例子中，定义了两个类Animal和Dog，其中Dog继承自Animal。在Animal中定义了move方法，在Dog中重写了move方法。在Main方法中实例化了Animal和Dog，分别调用了move方法。结果显示了不同的输出信息。

4. 泛型和通配符

泛型（Generics）和通配符（Wildcard）也是Java中的两个常用概念。

泛型指的是在定义类、接口或方法时使用类型参数，其中类型参数可以在使用时由调用方指定。通过使用泛型可以使程序更加类型安全和通用。

以下是示例代码：

public class Box<T> {
    private T t;

    public Box(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }

    public static void main(String[] args) {
        Box<String> box1 = new Box<>("Hello World");
        System.out.println(box1.get());

        Box<Integer> box2 = new Box<>(12345);
        System.out.println(box2.get());
    }
}

在这个例子中，定义了一个泛型类Box，其中类型参数为T。通过调用方可以指定不同的类型参数，分别实例化了Box<String>和Box<Integer>，并分别调用了get方法。

通配符指的是由?表示的非具体类型的类型参数。通过使用通配符可以定义更加通用的泛型类型，使得更多的类型可以作为参数传递。

以下是示例代码：

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void printList(List<?> list) {
        for (Object obj : list) {
            System.out.println(obj);
        }
    }

    public static void main(String[] args) {
        List<Integer> intList = new ArrayList<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);
        printList(intList);

        List<String> strList = new ArrayList<>();
        strList.add("Hello");
        strList.add("World");
        strList.add("Java");
        printList(strList);
    }
}

在这个例子中，定义了一个printList方法，使用通配符?作为参数类型，从而可以将不同类型的List作为参数传递，同时在方法中使用Object类型对参数进行遍历并打印输出。在main方法中实例化了List<Integer>和List<String>，并分别调用了printList方法。