Java基础2

1.抽象类

在Java中，抽象类（Abstract Class）是一种特殊类型的类，它不能被实例化，而是用于被其他类继承。抽象类可以包含抽象方法和具体方法。

以下是关于抽象类的一些关键点：

  1. 定义抽象类：

    • 使用abstract关键字定义抽象类。
    • 不能实例化抽象类，即不能使用new关键字创建抽象类的对象。
      复制代码
      abstract class Shape {
    // 抽象方法
    abstract void draw();

    // 具体方法
    void display() {
        System.out.println("Displaying shape");
    }
}
      复制代码
     

  2. 抽象方法：

    • 抽象方法是在抽象类中声明但没有实现的方法。
    • 子类必须提供对抽象方法的具体实现。
    • 抽象方法使用abstract关键字声明，不包含方法体。 
      abstract class Shape {
    abstract void draw();
}

       

  3. 子类继承抽象类：

    • 子类使用extends关键字继承抽象类。
    • 子类必须提供对抽象方法的实现，否则子类也必须声明为抽象类。 
      class Circle extends Shape {
    // 实现抽象方法
    void draw() {
        System.out.println("Drawing a circle");
    }
}
     

  4. 抽象类的作用：

    • 提供一种模板或基类，定义一些通用的属性和方法。
    • 强制子类提供对抽象方法的实现，确保子类的一致性。

  5. 抽象类与接口的比较：

    • 抽象类可以包含具体方法，而接口只能包含抽象方法。
    • 一个类只能继承一个抽象类，但可以实现多个接口。
    • 接口更灵活，适用于多继承的场景。
      复制代码
      // 示例：使用抽象类和子类
abstract class Shape {
    abstract void draw();

    void display() {
        System.out.println("Displaying shape");
    }
}

class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a circle");
    }
}

class Rectangle extends Shape {
    void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.draw();
        circle.display();

        Rectangle rectangle = new Rectangle();
        rectangle.draw();
        rectangle.display();
    }
}
      复制代码

上述例子中，Shape是抽象类，Circle和Rectangle是其子类，分别实现了抽象方法draw。

2.类的高级特性

  1. 继承（Inheritance）：

    • 允许一个类（子类）基于另一个类（父类）的定义来创建，并且可以使用父类的属性和方法。
    • 子类可以继承父类的非私有属性和方法，并且可以通过重写方法来实现多态。
      复制代码
      class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    // 可以使用父类的eat方法
    // 也可以重写eat方法
    void eat() {
        System.out.println("Dog is eating");
    }
}
      复制代码

       

  2. 多态（Polymorphism）：

    • 多态允许同一个方法在不同的对象上表现出不同的行为。
    • 通过方法的重写和接口实现实现多态。 
      Animal myAnimal = new Dog();
myAnimal.eat();  // 调用的是Dog类的eat方法

  3. 封装（Encapsulation）：

    • 封装是将对象的状态和行为包装在一起，并对外部隐藏对象的内部细节。
    • 使用私有属性和公有方法来实现封装。
      复制代码
      class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String newName) {
        name = newName;
    }
}
      复制代码

       

  4. 接口（Interface）：

    • 接口定义了一组抽象方法，类可以实现一个或多个接口。
    • 接口提供了一种多继承机制，类可以实现多个接口。
      复制代码
      interface Drawable {
    void draw();
}

class Circle implements Drawable {
    public void draw() {
        System.out.println("Drawing a circle");
    }
}
      复制代码

      这些高级特性使得Java的面向对象编程更加灵活和强大，允许开发者更好地组织和管理代码。

 3.代码块

在Java中，代码块是一组被包含在花括号 {} 中的代码语句。代码块可以出现在类、方法、循环或条件语句中。主要有两种类型的代码块：普通代码块和静态代码块。

1. 普通代码块（Instance Initialization Block）：

普通代码块用于定义在类中，不带任何修饰符。它在对象创建时执行，优先于构造方法。

复制代码
public class Example {
    // 构造方法
    public Example() {
        System.out.println("Constructor");
    }

    // 普通代码块
    {
        System.out.println("Instance Initialization Block");
    }

    public static void main(String[] args) {
        Example obj = new Example();
    }
}
复制代码

输出：

Instance Initialization Block
Constructor
 

2. 静态代码块（Static Initialization Block）：

静态代码块用于定义在类中，使用 static 修饰。它在类加载时执行，只执行一次。

复制代码
public class Example {
    // 静态代码块
    static {
        System.out.println("Static Initialization Block");
    }

    // 构造方法
    public Example() {
        System.out.println("Constructor");
    }

    public static void main(String[] args) {
        Example obj1 = new Example();
        Example obj2 = new Example();
    }
}
复制代码

输出：

Static Initialization Block
Constructor
Constructor

 

3. 局部代码块（Local Block）：

局部代码块是在方法或语句中创建的代码块，用于限定变量的作用范围。

复制代码
public class Example {
    public static void main(String[] args) {
        int x = 10;

        // 局部代码块
        {
            int y = 20;
            System.out.println(x);  // 可以访问外部代码块的变量
            System.out.println(y);
        }

        // System.out.println(y);  // 编译错误，y的作用范围仅限于上面的局部代码块
    }
}
复制代码

 

在实际编程中，代码块常用于初始化块、资源管理、局部变量的作用范围控制等场景。静态代码块经常用于执行类加载时的初始化工作。

 

4.. 构造代码块

是定义在类中的一种特殊的代码块，它在对象被创建时执行，位于类中成员变量声明的位置，被花括号 {} 包围。构造代码块在每次创建对象时都会执行，优先于构造方法。

构造代码块的主要作用是在对象创建时执行一些初始化操作，与构造方法共同完成对象的初始化工作。下面是构造代码块的基本语法：

复制代码
class MyClass {
    // 构造代码块
    {
        // 初始化代码
        // 这部分代码会在每次对象创建时执行
    }

    // 构造方法
    public MyClass() {
        // 构造方法代码
        // 这部分代码在对象创建时执行
    }
}
复制代码

 

以下是一个示例，展示了构造代码块的使用：

复制代码
public class Example {
    private int x;

    // 构造代码块
    {
        // 初始化代码
        x = 5;
        System.out.println("Constructing an object with x = " + x);
    }

    // 构造方法
    public Example() {
        // 构造方法代码
        System.out.println("Inside the constructor");
    }

    public static void main(String[] args) {
        Example obj = new Example();
    }
}
复制代码

 

输出：

Constructing an object with x = 5
Inside the constructor

 

在上述示例中，构造代码块中的初始化代码在对象创建时执行，然后再执行构造方法的代码。构造代码块适用于在每次对象创建时都需要执行的初始化逻辑，可以提高代码的可维护性。

 4.匿名对象

在Java中，匿名对象是指没有明确赋值给任何变量的对象，通常在创建对象的同时调用其方法。匿名对象通常用于一次性的操作，不需要将对象保存到变量中。

以下是一个简单的示例，演示了匿名对象的使用：

复制代码
public class Example {
    public static void main(String[] args) {
        // 创建匿名对象并调用方法
        new MyClass().display();
        
        // 创建匿名对象并传递参数
        int result = new Calculator().add(5, 3);
        System.out.println("Result: " + result);
    }
}

class MyClass {
    public void display() {
        System.out.println("Inside MyClass");
    }
}

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}
复制代码

 

 

在上述示例中，new MyClass().display()创建了一个匿名对象，并立即调用了其display方法。同样，new Calculator().add(5, 3)创建了一个匿名对象，并直接调用了其add方法。

匿名对象的使用通常适用于以下情况：

  1. 一次性使用： 当对象仅在一个地方使用一次，不需要重复引用时。
  2. 简化代码： 对于简单的操作，可以通过匿名对象减少代码行数。

需要注意的是，由于匿名对象没有被赋值给变量，因此无法再次使用或引用。如果需要多次使用对象，应该将其赋值给变量。

 5.内部类

在Java中，内部类是定义在另一个类内部的类。内部类有以下几种类型：

       内部类（Inner Class）：

  • 内部类是定义在其他类内部的类。
  • 内部类可以访问外部类的成员，包括私有成员。
    复制代码
    class Outer {
    private int x;

    class Inner {
        void display() {
            System.out.println("Value of x: " + x);
        }
    }
}
    复制代码

  1. 成员内部类（Member Inner Class）：

    • 成员内部类是定义在另一个类的内部的类，并且它是外部类的成员之一。
    • 成员内部类可以访问外部类的成员，包括私有成员。
    • 成员内部类可以用static修饰，此时它就变成了静态内部类。
      复制代码
      public class Outer {
    private int outerVar;

    // 成员内部类
    class Inner {
        void display() {
            System.out.println("OuterVar from Inner: " + outerVar);
        }
    }
}
      复制代码

       

    public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.display();
    }
}

     

  2. 局部内部类（Local Inner Class）：

    • 局部内部类是定义在方法内部的类。
    • 局部内部类只能在定义它的方法中访问，生命周期仅限于方法的执行过程。
    复制代码
    public class Outer {
    void outerMethod() {
        // 局部内部类
        class LocalInner {
            void display() {
                System.out.println("Inside Local Inner");
            }
        }

        // 创建局部内部类对象并调用方法
        LocalInner localInner = new LocalInner();
        localInner.display();
    }
}
    复制代码
    public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerMethod();
    }
}

     

  3. 匿名内部类（Anonymous Inner Class）：

    • 匿名内部类是一种没有类名的局部内部类，通常用于实现接口或继承类。
    • 匿名内部类一般在创建对象的同时进行定义，适用于一次性使用的情况。
      复制代码
      interface Greeting {
    void greet();
}

public class Main {
    public static void main(String[] args) {
        // 使用匿名内部类实现接口
        Greeting greeting = new Greeting() {
            @Override
            public void greet() {
                System.out.println("Hello, world!");
            }
        };

        greeting.greet();
    }
}
      复制代码

       

     

内部类提供了一种更灵活的组织代码的方式，并允许在一个类内部定义与外部类关联紧密的类。然而，过多地使用内部类可能会导致代码的复杂性增加，因此需要根据具体情况慎重选择使用内部类的方式。

 
 
posted @   庄佳星  阅读(17)  评论(0)  编辑  收藏  举报
相关博文：
· java期末复习，阳光学院
· Java语言基础知识梳理与总结
· 面向对象编程：深入理解内部类与抽象类的使用
· Java学习笔记10
· 初学须知之Java的抽象类与接口
阅读排行：
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· Docker 太简单，K8s 太复杂？w7panel 让容器管理更轻松！
点击右上角即可分享
微信分享提示