java(oop)基础知识

月光与廊桥

已于 2024-07-30 21:33:30 修改

阅读量638

点赞数 11

文章标签： java 开发语言

于 2024-07-30 21:32:53 首次发布

本文链接：https://blog.csdn.net/2301_80140904/article/details/140806753

版权

public class Book {
    // 属性
    private String title;
    private String author;
    private int publicationYear;
    private boolean isAvailable;

    // 方法
    // 构造方法
    public Book(String title, String author, int publicationYear) {
        this.title = title;
        this.author = author;
        this.publicationYear = publicationYear;
        this.isAvailable = true;
    }

    // 其他方法，如获取和设置属性的方法
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    // 更多方法...
}

2. 对象（Object）

对象是类的一个实例，通过关键字new来创建。一个类的多个对象可以同时存在，每个对象有自己的属性值。

public class Main {
    public static void main(String[] args) {
        // 创建 Book 对象
        Book book1 = new Book("Java Programming", "John Smith", 2020);
        Book book2 = new Book("Data Structures and Algorithms", "Jane Doe", 2018);

        // 使用对象的方法和属性
        System.out.println("Book 1 title: " + book1.getTitle());
        System.out.println("Book 2 author: " + book2.getAuthor());

        // 修改对象的属性
        book1.setTitle("Advanced Java Programming");

        // 更多操作...
    }
}

3. 继承（Inheritance）

继承允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以重用父类的代码，并且可以添加新的方法或属性。

// 父类
public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

// 子类继承父类
public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // 继承自父类
        dog.bark(); // 子类自己的方法
    }
}

4. 多态（Polymorphism）

多态性允许一个方法在不同的对象上具有不同的行为。它分为编译时多态（方法重载）和运行时多态（方法重写）。

// 父类
public class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

// 子类重写父类方法
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();

        dog.makeSound();  // 输出：Dog barks
        cat.makeSound();  // 输出：Cat meows
    }
}

5. 封装（Encapsulation）

封装将类的实现细节隐藏起来，只向外部提供公共的访问方式（如方法）。通过将字段声明为私有（private），并提供公共的访问方法（如get和set方法），可以控制对类的访问。

public class Book {
    private String title;
    private String author;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    // 更多方法...
}

6. 抽象类（Abstract Class）

抽象类不能被实例化，用abstract关键字声明。它可以包含抽象方法（没有实现的方法）和非抽象方法。子类必须实现抽象类中的所有抽象方法。

// 抽象类
public abstract class Shape {
    // 抽象方法
    public abstract double calculateArea();
}

// 子类实现抽象类
public class Circle extends Shape {
    private double radius;

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }

    // 构造方法、其他方法等...
}

7. 接口（Interface）

接口定义了一组方法的规范，但没有方法的实现。类通过implements关键字来实现接口，并实现接口中定义的所有方法。

// 接口
public interface Printable {
    void print();
}

// 类实现接口
public class Document implements Printable {
    @Override
    public void print() {
        System.out.println("Printing document...");
    }
}

public class Main {
    public static void main(String[] args) {
        Printable doc = new Document();
        doc.print();  // 输出：Printing document...
    }
}

8. 构造方法（Constructor）

构造方法是一种特殊的方法，用于初始化对象。在Java中，构造方法的名称必须与类名相同，并且没有返回类型（甚至不是void）。

public class Book {
    private String title;
    private String author;

    // 构造方法
    public Book(String title, String author) {
        this.title = title;
        this.author = author;
    }

    // 其他方法...
}

9. 方法重载（Method Overloading）

方法重载是指在同一个类中，可以有多个方法具有相同的名称，但参数列表不同（类型、顺序或数量）。编译器根据方法调用时传递的参数类型和数量来决定调用哪个方法。

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

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

    // 更多重载方法...
}

10. 静态关键字（Static Keyword）

static关键字用于创建静态成员变量和静态方法。静态成员属于类而不是对象，可以通过类名直接访问，而不需要实例化对象。

public class Counter {
    private static int count = 0;

    public Counter() {
        count++;
    }

    public static int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        
        System.out.println(Counter.getCount());  // 输出：2
    }
}

11. 包（Package）

包是一种命名空间，用于组织类和接口。Java使用包来避免命名冲突，并提供了更好的模块化和封装性。

// 定义包
package com.example.myapp;

// 导入其他包中的类
import com.example.otherpackage.OtherClass;

// 定义类在包中
public class MyClass {
    // 类的内容
}

12. 异常处理（Exception Handling）

异常处理是Java中处理运行时错误和异常情况的重要机制。使用try-catch-finally块来捕获和处理异常，保证程序在发生错误时可以优雅地处理并进行恢复。

public class Example {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage());
        } finally {
            System.out.println("Execution completed.");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

13. Lambda表达式

Lambda表达式是Java 8引入的一个重要特性，用于提供函数式编程的支持。它可以使代码更加简洁和易读。

public class LambdaExample {
    public static void main(String[] args) {
        // 使用Lambda表达式实现Runnable接口
        Runnable r = () -> {
            System.out.println("Running in a separate thread");
        };

        // 使用Lambda表达式作为参数
        Thread t = new Thread(r);
        t.start();
    }
}

14. 泛型（Generics）

泛型允许在类或方法中使用类型参数，从而提高代码的类型安全性和重用性。

// 泛型类
public class Box<T> {
    private T content;

    public void add(T content) {
        this.content = content;
    }

    public T get() {
        return content;
    }
}

// 泛型方法
public class Util {
    public static <T> T getElement(T[] array, int index) {
        return array[index];
    }
}

15. 注解（Annotations）

注解提供了元数据，可以用于在类、方法或字段上添加信息，用于编译时处理或运行时处理。

// 自定义注解
import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MethodInfo {
    String author() default "Unknown";
    String date();
    int version() default 1;
}

// 使用注解
public class MyClass {
    @MethodInfo(author = "John", date = "2024-07-30", version = 2)
    public void performTask() {
        // 方法内容
    }
}