Java面向对象进阶(超详细)

爱摸鱼的呆瓜

已于 2024-03-23 14:02:41 修改

阅读量657

点赞数 32

文章标签： java 开发语言

于 2024-03-23 14:01:56 首次发布

本文链接：https://blog.csdn.net/m0_58111460/article/details/136950670

版权

本文章主要包含static、继承、包、final、权限修饰符、代码块、抽象类、接口、多态、内部类

如果对创建对象不了解，可以转至Java面向对象-CSDN博客

一、static

在Java中，static 关键字是一个非常重要的修饰符，它可以用来修饰变量、方法、代码块以及内部类。以下是关于 static 关键字的详细解释：

静态变量（Static Variables）:
- 静态变量属于类本身，而不是类的某个对象。
- 静态变量在类加载时就被初始化，并且只初始化一次。
- 静态变量可以在没有创建类的任何对象的情况下访问。
- 使用 static 修饰的变量通常被用作常量。

public class MyClass { 
public static int MY_CONSTANT = 100; 
} 


// 访问静态变量 
int value = MyClass.MY_CONSTANT;

静态方法（Static Methods）:
- 静态方法属于类本身，而不是类的某个对象。
- 静态方法只能访问静态变量或静态方法，不能直接访问非静态变量或非静态方法（除非通过对象引用）。
- 静态方法可以通过类名直接调用。

public class MyClass { 
public static void myStaticMethod() { 
System.out.println("This is a static method."); 
} 
} 


// 调用静态方法 
MyClass.myStaticMethod();

静态代码块（Static Blocks）:
- 静态代码块在类加载时执行，且只执行一次。
- 通常用于初始化静态变量或执行只需执行一次的操作。

public class MyClass { 
public static int myStaticVar; 


static { 
myStaticVar = 42; 
System.out.println("Static block executed."); 
} 
}

静态内部类（Static Inner Classes）:
- 静态内部类可以不依赖于外部类实例而被实例化。
- 静态内部类不能访问外部类的非静态成员，但可以访问外部类的静态成员。

public class OuterClass {  
    private static String outerStaticVar = "Outer";  
      
    public static class StaticNestedClass {  
        public void printMessage() {  
            System.out.println(outerStaticVar);  
        }  
    }  
}  
  
// 使用静态内部类  
OuterClass.StaticNestedClass nestedObj = new OuterClass.StaticNestedClass();  
nestedObj.printMessage(); // 输出 "Outer"

注意事项：

静态成员（变量和方法）的访问不依赖于对象，因此它们不能通过 this 关键字来访问。
在多线程环境下，静态变量是共享的，因此需要注意线程安全问题。
静态方法不能访问非静态成员，因为非静态成员依赖于具体的对象实例，而静态方法不依赖于任何对象实例。

二、继承

Java中的继承是一个面向对象编程的核心概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。通过这种方式，子类可以重用父类的代码，并且可以添加或覆盖自己的特定属性和方法。

以下是Java继承的详细解释：

1. 继承的定义

在Java中，你可以使用extends关键字来定义一个类继承另一个类。例如：

class Animal {  
    void eat() {  
        System.out.println("Animal eats");  
    }  
}  
  
class Dog extends Animal {  
    void bark() {  
        System.out.println("Dog barks");  
    }  
}

在这个例子中，Dog类继承了Animal类，因此Dog类自动拥有了Animal类的eat()方法。

2. 访问父类的成员

如果子类需要访问或调用父类的成员（属性或方法），可以使用super关键字。例如：

class Dog extends Animal {  
    void eat() {  
        super.eat(); // 调用父类的eat()方法  
        System.out.println("Dog eats dog food");  
    }  
}

3. 方法的覆盖（Override）

子类可以覆盖父类的方法，即子类可以定义一个与父类相同名称和参数列表的方法。这样，当使用子类对象调用该方法时，将执行子类的方法而不是父类的方法。覆盖方法时，子类方法的访问权限不能低于父类方法的访问权限。

class Dog extends Animal {  
    @Override // 使用@Override注解可以表示该方法是对父类方法的覆盖  
    void eat() {  
        System.out.println("Dog eats dog food");  
    }  
}

4. 构造方法的继承

构造方法不会被继承。但是，子类构造方法中可以使用super()关键字调用父类的构造方法。如果子类构造方法中没有显式调用父类构造方法，则会自动调用父类的无参构造方法。

class Dog extends Animal {  
    Dog() {  
        super(); // 调用父类的无参构造方法  
    }  
    // ...  
}

5. 多层继承

Java支持多层继承，即一个类可以继承自另一个继承自其他类的类。但请注意，Java不支持多重继承，即一个类不能同时继承多个父类。

6. 继承与访问修饰符

继承受到访问修饰符的影响。如果一个类的成员被声明为private，则它不能被任何子类访问。如果成员被声明为protected，则它可以在同一个包中的类以及所有子类中被访问。如果成员没有访问修饰符（默认为包级访问），则它只能在其所属的包中的类以及同一个包中的子类中被访问。如果成员被声明为public，则它可以在任何地方被访问。

7. 继承的优缺点

优点：代码重用、扩展性、易于维护。
缺点：可能导致类之间的紧耦合，增加系统的复杂性，降低系统的灵活性。

通过合理使用继承，你可以构建出更灵活、更易于维护的Java应用程序。

三、多态

Java中的多态（Polymorphism）是面向对象编程的三大特性之一，它允许我们以统一的方式处理不同类型的对象。多态性意味着可以将子类的对象当作父类的对象使用，这使得程序更加灵活和可扩展。下面将详细解释Java中的多态性。

1. 多态性的体现

在Java中，多态性主要体现在以下几个方面：

1.1 方法重载（Overloading）

在同一个类中，可以有多个同名但参数列表不同的方法，这就是方法重载。虽然重载与多态性在概念上有所不同，但它是多态性的一种体现。

1.2 方法覆盖（Overriding）

子类可以覆盖父类中的方法，这样当使用父类引用指向子类对象时，调用的是子类中的方法。这是多态性在Java中的核心体现。

1.3 接口的多态性

一个接口引用可以指向实现了该接口的任何类的对象。这样，我们可以使用接口引用来统一处理不同类型的对象。

2. 多态性的实现机制

在Java中，多态性主要通过以下两种方式实现：

2.1 方法重写（Override）与动态绑定（Dynamic Binding）

当子类重写了父类的方法后，通过父类引用调用该方法时，实际调用的是子类中的方法。这种在运行时确定调用哪个方法的过程称为动态绑定。

2.2 接口与抽象类

通过接口和抽象类，我们可以定义一组方法的契约，然后由不同的类来实现这些方法。这样，我们就可以使用接口或抽象类的引用来统一处理实现了这些方法的类的对象。

3. 多态性的优点

3.1 代码可重用性

多态性允许我们使用统一的接口来处理不同的对象，从而提高了代码的可重用性。

3.2 扩展性

由于多态性允许我们处理未知类型的对象，因此它使得代码更加灵活和可扩展。

3.3 简化代码

通过多态性，我们可以避免使用大量的条件语句来判断对象的类型，从而简化代码结构。

4. 示例

下面是一个简单的Java多态性示例：

class Animal {  
    void makeSound() {  
        System.out.println("The animal makes a sound");  
    }  
}  
  
class Dog extends Animal {  
    @Override  
    void makeSound() {  
        System.out.println("The dog barks");  
    }  
}  
  
class Cat extends Animal {  
    @Override  
    void makeSound() {  
        System.out.println("The cat meows");  
    }  
}  
  
public class PolymorphismDemo {  
    public static void main(String[] args) {  
        Animal animal1 = new Dog(); // 父类引用指向子类对象  
        Animal animal2 = new Cat(); // 父类引用指向另一个子类对象  
          
        animal1.makeSound(); // 输出 "The dog barks"  
        animal2.makeSound(); // 输出 "The cat meows"  
    }  
}

在这个示例中，我们定义了一个Animal类以及两个子类Dog和Cat。Dog和Cat都重写了Animal类中的makeSound()方法。在PolymorphismDemo类的main方法中，我们使用Animal类型的引用来引用Dog和Cat对象，并调用它们的makeSound()方法。由于多态性的存在，实际调用的是子类中的方法。

四、包和final

在Java中，包（Package）和final关键字都是非常重要的概念，它们各自在Java编程中扮演着不同的角色。下面我将分别详细解释这两个概念。

包（Package）

1. 定义与用途

包是Java中用于组织类的一种机制。通过将相关的类组织在同一个包中，我们可以更好地管理代码，避免命名冲突，并实现代码的重用和封装。

2. 包的声明

在Java源文件的顶部，可以使用package关键字声明该文件所属的包。例如：

package com.example;  
  
public class MyClass {  
    // ...  
}

这表示MyClass类属于com.example包。

3. 访问控制

包还可以用于控制类的访问权限。默认情况下，一个包中的类不能访问另一个包中的非公开（非public）成员。通过设置类的访问修饰符（如public、protected、默认（无修饰符）或private），可以控制其他包中的类对该类的访问权限。

4. 导入包

如果需要使用其他包中的类，可以使用import关键字导入该包。例如：

import java.util.ArrayList;  
  
public class MyClass {  
    ArrayList<String> myList = new ArrayList<>();  
    // ...  
}

这表示导入了java.util包中的ArrayList类，以便在MyClass中使用。

final

1. 定义与用途

final是Java中的一个关键字，用于表示一个变量、方法或类是不可变的。它主要用于确保某个变量、方法或类的状态在程序运行过程中保持不变，从而提高程序的稳定性和可维护性。

2. final变量

当变量被声明为final时，它的值在初始化后就不能再被修改。这可以用于定义常量。例如：

public static final int MAX_VALUE = 100;

这里定义了一个名为MAX_VALUE的常量，其值为100，且这个值在程序运行过程中不能被修改。

3. final方法

当方法被声明为final时，它不能被任何子类覆盖（重写）。这有助于确保某个方法的行为在继承体系中保持一致。例如：

public final void myMethod() {  
    // ...  
}

这里定义了一个名为myMethod的final方法，任何继承该类的子类都不能覆盖这个方法。

4. final类

当类被声明为final时，它不能被继承。这有助于防止其他类扩展该类并修改其行为。例如：

public final class MyFinalClass {  
    // ...  
}

这里定义了一个名为MyFinalClass的final类，其他类不能继承这个类。

注意：虽然final关键字可以提高程序的稳定性和可维护性，但过度使用它可能会导致代码变得僵硬，难以扩展和维护。因此，在使用final时，需要权衡其优缺点并根据实际情况做出决策。

五、权限修饰符与代码块

在Java中，权限修饰符和代码块是两个重要的概念，它们对于控制类的访问权限和初始化过程起着关键作用。下面我将详细解释这两个概念。

权限修饰符

Java提供了四种访问修饰符，它们用于定义类、方法、变量或其他成员的访问权限。这四种访问修饰符分别是：

public：
- 类、方法、变量都可以被任何其他类访问。
- 如果一个类被声明为public，那么它必须被定义在一个文件中，且文件名必须与类名相同。
protected：
- 对同一个包内的其他类可见，对其他包中的子类也可见。
- 主要用于实现子类能够访问父类的特定成员，但又不希望这些成员被其他非子类的类访问。
默认（无修饰符）：
- 也称为包级私有，只对同一个包内的其他类可见。
- 如果不显式地使用访问修饰符，那么默认使用这种访问级别。
private：
- 仅对定义它的类可见。
- 私有成员只能在其所在的类中被访问，不能从类的外部访问。

代码块

Java中的代码块主要分为四种：静态代码块、实例初始化块、构造代码块和同步代码块。每种代码块都有其特定的用途和执行时机。

静态代码块（static block）：
- 使用static关键字定义，只执行一次，当类被加载到JVM时执行。
- 常用于初始化类的静态变量或执行只需执行一次的操作。
```
public class MyClass {  
    static {  
        // 静态代码块内容，类加载时执行  
    }  
}
```
实例初始化块（非静态初始化块）：
- 不使用任何修饰符定义，每次创建类的实例时都会执行。
- 常用于执行每次创建对象时都需要进行的初始化操作。
```
public class MyClass {  
    {  
        // 实例初始化块内容，每次创建对象时执行  
    }  
}
```
构造代码块：
- 实际上构造代码块就是实例初始化块，它们是等价的。当创建类的对象时，构造代码块会被执行。
- 如果类定义了构造方法，构造代码块会在构造方法之前执行。
同步代码块（synchronized block）：
- 使用synchronized关键字定义，用于实现多线程环境下的同步访问。
- 同步代码块确保一次只有一个线程可以执行代码块中的代码。
```
public class MyClass {  
    public void myMethod() {  
        synchronized (this) {  
            // 同步代码块内容，一次只有一个线程可以执行  
        }  
    }  
}
```

权限修饰符和代码块是Java编程中非常重要的概念。权限修饰符帮助我们控制类的成员（包括类、方法、变量等）的可见性，从而确保数据的安全性和类的封装性。而代码块则用于执行各种初始化操作和同步访问，确保程序在运行时能够正确地执行所需的逻辑。

六、抽象类和抽象方法

在Java中，抽象类和抽象方法是面向对象编程的两个重要概念。它们允许我们定义一种更通用的结构，而不必立即提供所有的实现细节。下面，我将详细解释这两个概念。

抽象类（Abstract Class）

抽象类是一种特殊的类，它不能被实例化（即不能创建抽象类的对象）。抽象类通常包含抽象方法，也可以包含非抽象方法、变量和构造器。抽象类的主要目的是作为其他类的基类，为子类提供一个通用的模板。

抽象类使用abstract关键字来声明。例如：

abstract class AbstractClass {  
    // 抽象方法，没有方法体  
    abstract void abstractMethod();  
  
    // 非抽象方法  
    void nonAbstractMethod() {  
        // 实现细节  
    }  
}

在这个例子中，AbstractClass是一个抽象类，它有一个抽象方法abstractMethod和一个非抽象方法nonAbstractMethod。抽象方法只有声明，没有方法体。

抽象方法（Abstract Method）

抽象方法是没有实现的方法，也就是说它们没有方法体。抽象方法必须在抽象类中声明，而且子类必须提供抽象方法的具体实现，除非子类本身也是抽象的。

抽象方法也是用abstract关键字声明的，且抽象方法只有声明，没有花括号和方法体。例如：

abstract class AbstractClass {  
    // 这是一个抽象方法  
    abstract void someAbstractMethod();  
}

如果一个类继承了一个抽象类，它必须实现抽象类中声明的所有抽象方法，除非这个类本身也是抽象的。例如：

class SubClass extends AbstractClass {  
    // 必须实现父类中的抽象方法  
    @Override  
    void someAbstractMethod() {  
        // 实现细节  
    }  
}

在这个例子中，SubClass继承了AbstractClass并实现了其中的抽象方法someAbstractMethod。如果SubClass没有实现someAbstractMethod，那么SubClass也必须被声明为抽象类。

抽象类和抽象方法的使用场景

抽象类和抽象方法常常用于创建具有共同特征的类的层次结构，但某些实现细节在不同子类中有所不同的情况。例如，你可能有一个Animal抽象类，它有一个抽象方法makeSound()，因为不同的动物发出不同的声音。然后你可以有Dog、Cat等子类来实现makeSound()方法。

注意事项

抽象类不能被实例化。
抽象类可以包含抽象方法和非抽象方法。
抽象方法没有方法体，且必须在抽象类中声明。
如果一个类继承了一个抽象类，它必须提供抽象类中所有抽象方法的具体实现，除非这个类也是抽象的。
抽象类可以包含构造器，主要用于被子类调用。

七、接口

在Java中，接口（Interface）是一种引用类型，它是方法的集合，这些方法可以被类实现（也称为实现接口）。接口不能被实例化，即不能创建接口的对象。接口主要用于定义一组行为的规范，实现这些接口的类必须遵守这些规范。

接口的声明

接口使用interface关键字声明，接口中的方法默认是抽象的，所以不需要使用abstract关键字。接口中只能包含抽象方法、默认方法、静态方法和常量。

public interface MyInterface {  
    void method1(); // 抽象方法，没有方法体  
      
    default void method2() {  
        // 默认方法，有方法体，实现接口的类可以选择是否覆盖此方法  
    }  
      
    static void method3() {  
        // 静态方法，只能通过接口名直接调用  
    }  
      
    int constant = 10; // 常量，默认是public static final的  
}

接口的实现

一个类可以实现一个或多个接口，使用implements关键字。实现接口的类必须提供接口中所有抽象方法的具体实现。

public class MyClass implements MyInterface {  
    @Override  
    public void method1() {  
        // 实现接口中的抽象方法  
    }  
      
    // MyClass不需要实现method2()，因为它是默认方法  
    // MyClass也不能直接调用method3()，因为它是静态方法  
}

接口的特点

抽象性：接口中的所有方法默认是抽象的，没有方法体。
多态性：接口可以被不同的类实现，从而体现多态性。
继承性：接口可以继承其他接口，使用extends关键字。
常量性：接口中声明的变量默认是public static final的，即常量。
互操作性：接口可以与抽象类配合使用，以提供更灵活的设计。

接口与抽象类的比较

接口和抽象类都是用来定义一组行为的规范，但它们之间存在一些重要的区别：

实现与继承：类实现接口使用implements关键字，而类继承抽象类使用extends关键字。一个类可以实现多个接口，但只能继承一个抽象类（除了Java 8引入的接口的多继承）。
方法：接口中的方法默认是抽象的，抽象类中可以包含抽象方法和非抽象方法。
字段：接口中的字段默认是常量（public static final），而抽象类中的字段可以是任何类型。
设计目的：接口主要用于定义对象的行为，而抽象类主要用于定义对象的结构。

接口的用途

接口在Java编程中非常有用，它们可以用于：

定义一组相关的方法，这些方法可以由不同的类以不同的方式实现。
实现多态性，允许不同的对象以统一的方式被处理。
解耦，降低类与类之间的耦合度，提高代码的可维护性和可扩展性。
作为回调机制的一部分，例如在事件处理或观察者模式中。

八、内部类

Java内部类（Inner Class）是定义在另一个类内部的类。内部类可以访问其外部类的所有成员，包括私有成员，即使这些成员在外部类的实例化对象中也是不可见的。内部类提供了更好的封装和代码组织方式，同时减少了类之间的耦合。

Java内部类主要分为四种：成员内部类、静态内部类、局部内部类（包括定义在方法中的内部类和定义在代码块中的内部类）和匿名内部类。

1. 成员内部类

成员内部类是最普通的内部类，它定义在外部类的成员位置，可以访问外部类的所有成员（包括私有成员）。成员内部类不能被声明为static，它依赖于外部类的实例存在。

public class OuterClass {  
    private int outerVariable = 100;  
  
    class InnerClass {  
        void display() {  
            System.out.println("Outer variable value: " + outerVariable);  
        }  
    }  
  
    public static void main(String[] args) {  
        OuterClass outer = new OuterClass();  
        InnerClass inner = outer.new InnerClass(); // 访问内部类需要外部类实例  
        inner.display();  
    }  
}

2. 静态内部类

静态内部类使用static关键字修饰，它不依赖于外部类的实例，因此不能访问外部类的非静态成员，只能访问外部类的静态成员。静态内部类可以单独创建实例，而不需要外部类实例。

public class OuterClass {  
    private static int staticVariable = 200;  
  
    static class StaticInnerClass {  
        void display() {  
            System.out.println("Static variable value: " + staticVariable);  
        }  
    }  
  
    public static void main(String[] args) {  
        StaticInnerClass inner = new StaticInnerClass(); // 可以直接创建实例  
        inner.display();  
    }  
}

3. 局部内部类

局部内部类定义在方法或代码块中，它的作用域被限制在定义它的方法或代码块中。局部内部类只能访问定义它的方法或代码块中的final变量（Java 8以后，这个限制有所放宽，只要变量在内部类中的生命周期内不会改变，就可以被访问）。

public class OuterClass {  
    void show() {  
        final int localVariable = 300; // 可以是final的  
        class LocalInnerClass {  
            void display() {  
                System.out.println("Local variable value: " + localVariable);  
            }  
        }  
        LocalInnerClass inner = new LocalInnerClass();  
        inner.display();  
    }  
  
    public static void main(String[] args) {  
        OuterClass outer = new OuterClass();  
        outer.show();  
    }  
}

4. 匿名内部类

匿名内部类是没有名称的内部类，通常用于实现接口或继承一个类，并立即创建该类的实例。匿名内部类常用于事件处理、线程等场景。

interface MyInterface {  
    void doSomething();  
}  
  
public class OuterClass {  
    public static void main(String[] args) {  
        MyInterface myInterface = new MyInterface() {  
            @Override  
            public void doSomething() {  
                System.out.println("Doing something in anonymous inner class.");  
            }  
        };  
        myInterface.doSomething();  
    }  
}

内部类在Java中非常有用，它们提供了更好的代码组织方式，允许我们将逻辑紧密相关的类放在一起，同时也提供了更好的封装和访问控制。然而，过度使用内部类也可能导致代码结构复杂，难以理解和维护，因此需要谨慎使用。

爱摸鱼的呆瓜

关注

32
点赞
踩
19

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java面向对象进阶(超详细)

抽象类是一种特殊的类，它不能被实例化（即不能创建抽象类的对象）。抽象类通常包含抽象方法，也可以包含非抽象方法、变量和构造器。抽象类的主要目的是作为其他类的基类，为子类提供一个通用的模板。抽象类使用abstract关键字来声明。// 抽象方法，没有方法体// 非抽象方法// 实现细节在这个例子中，是一个抽象类，它有一个抽象方法和一个非抽象方法。抽象方法只有声明，没有方法体。抽象方法是没有实现的方法，也就是说它们没有方法体。
复制链接

扫一扫