Java编程类与对象：从基础语法到高级特性

文章目录

- - 1. 类与对象
  - 2. 构造方法
  - 3. 继承
  - 4. 接口
  - 5. 抽象类
  - 6. 方法重载
  - 7. 方法重写
  - 8. 多态
  - 9. 封装
  - 10. 静态变量和方法
  - 11. 内部类
  - 12. 匿名类
  - 13. 泛型
  - 14. 集合框架
  - 15. 异常处理
  - 16. 文件I/O
  - 17. 多线程
  - 18. 同步
  - 19. 高级多线程

1. 类与对象

在Java中，所有代码都必须包含在一个类中。类是创建对象的模板或蓝图，而对象是类的具体实例。

public class Dog {String name;public void bark() {System.out.println(name + " says: Bark!");}
}// 创建Dog类的对象
Dog myDog = new Dog();
myDog.name = "Rex";
myDog.bark(); // 调用bark方法

Dog是一个类。
name是该类的一个属性。
bark()是该类的一个方法。
myDog是Dog类的一个实例（对象），通过new Dog()创建。

2. 构造方法

构造方法用于初始化新创建的对象状态。它具有与类相同的名字，并且没有返回类型。

public class User {String name;// 构造方法public User(String newName) {name = newName;}
}User user = new User("Alice"); // 使用构造方法创建对象并初始化

3. 继承

继承允许一个类从另一个类继承属性和方法，从而实现代码重用。子类可以扩展或修改父类的行为。

public class Animal {void eat() {System.out.println("This animal eats food.");}
}public class Dog extends Animal {void bark() {System.out.println("The dog barks.");}
}Dog dog = new Dog();
dog.eat(); // 继承自Animal的方法
dog.bark(); // 自定义的方法

Dog类继承了Animal类，所以它可以使用Animal的所有非私有成员。

4. 接口

接口定义了一组行为规范，实现了这个接口的类必须提供这些行为的具体实现。

public interface Animal {void eat();
}public class Dog implements Animal {public void eat() {System.out.println("The dog eats.");}
}

Animal是一个接口，定义了一个eat方法。
Dog实现了Animal接口，并提供了eat方法的具体实现。

5. 抽象类

抽象类不能被实例化，但可以包含抽象方法，这些方法必须由子类实现。

public abstract class Animal {abstract void eat();
}public class Dog extends Animal {void eat() {System.out.println("The dog eats.");}
}

Animal是一个抽象类，其中eat是抽象方法。
Dog继承了Animal并且实现了eat方法。

6. 方法重载

同一个类中可以有多个同名但参数列表不同的方法，这称为方法重载。

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

Calculator类中有三个名为add的方法，它们根据传入参数的不同执行不同的操作。

7. 方法重写

子类可以通过提供与父类中同名方法相同的签名来重写父类的方法。

public class Animal {void makeSound() {System.out.println("Some sound");}
}public class Dog extends Animal {@Overridevoid makeSound() {System.out.println("Bark");}
}

Dog类重写了Animal类的makeSound方法，以改变其行为。

8. 多态

多态性是指同一个接口或基类可以有不同的实现形式。例如，你可以用一个父类类型的引用指向子类的对象。

Animal myAnimal = new Dog();
myAnimal.makeSound(); // 输出 "Bark"
myAnimal = new Cat();
myAnimal.makeSound(); // 输出 "Meow"

Animal类型的变量myAnimal可以指向Dog或Cat对象，并调用各自版本的makeSound方法。

9. 封装

封装是隐藏对象的内部表示，只暴露必要的部分给外部使用的机制。通常通过设置成员变量为私有(private)，并通过公共(public)方法访问这些变量。

public class Account {private double balance;public Account(double initialBalance) {if (initialBalance > 0) {balance = initialBalance;}}public void deposit(double amount) {if (amount > 0) {balance += amount;}}public void withdraw(double amount) {if (amount <= balance) {balance -= amount;}}public double getBalance() {return balance;}
}

balance是私有成员，只能通过Account类提供的方法访问。

10. 静态变量和方法

静态成员属于类本身而不是特定的对象实例，因此所有对象共享同一份静态成员。

public class MathUtils {public static final double PI = 3.14159;public static double add(double a, double b) {return a + b;}
}

PI是一个静态常量，add是一个静态方法，可以直接通过类名访问，无需创建对象实例。

11. 内部类

内部类是在另一个类内部定义的类，它可以访问外部类的所有成员。

public class OuterClass {private String msg = "Hello";class InnerClass {void display() {System.out.println(msg);}}public void printMessage() {InnerClass inner = new InnerClass();inner.display();}
}

InnerClass是OuterClass的内部类，可以直接访问OuterClass的私有成员。

12. 匿名类

匿名类是没有名字的类，通常用于简化代码，特别是在需要快速创建对象的时候。

abstract class SaleTodayOnly {abstract int dollarsOff();
}public class Store {public SaleTodayOnly sale = new SaleTodayOnly() {int dollarsOff() {return 3;}};
}

这里创建了一个匿名类的实例，它实现了SaleTodayOnly抽象类。

13. 泛型

泛型允许你编写能够处理多种类型的代码，同时保持类型安全。

public class Box<T> {private T t;public void set(T t) {this.t = t;}public T get() {return t;}
}Box<Integer> integerBox = new Box<>();
integerBox.set(10);
System.out.println(integerBox.get()); // 应输出：10

Box<T>是一个泛型类，可以存储任何类型的对象。

14. 集合框架

集合框架是一组接口和实现类，用于更高效地管理和操作数据集合。

import java.util.ArrayList;
ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");
System.out.println(list); // 应输出：[Java, Python, C++]import java.util.HashMap;
HashMap<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
map.put("Cherry", 3);
System.out.println(map.get("Apple")); // 应输出：1

ArrayList是一个动态数组，HashMap是键值对的集合。

15. 异常处理

异常处理机制允许程序捕获和响应错误条件。

try {int result = 10 / 0;
} catch (ArithmeticException e) {System.out.println("Cannot divide by zero!");
} finally {System.out.println("This will always be printed.");
}

try块包含可能抛出异常的代码。
catch块捕获特定类型的异常并处理它。
finally块无论是否发生异常都会被执行。

16. 文件I/O

文件输入输出操作涉及到读取和写入文件内容。

读取文件

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;String line;
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {while ((line = br.readLine()) != null) {System.out.println(line);}
} catch (IOException e) {e.printStackTrace();
}

写入文件

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {bw.write("Hello World!");
} catch (IOException e) {e.printStackTrace();
}

BufferedReader和BufferedWriter用于高效地读取和写入文本文件。

17. 多线程

多线程编程可以让程序同时执行多个任务，提高应用程序的响应性和性能。

创建线程

class MyThread extends Thread {public void run() {System.out.println("MyThread running");}
}MyThread myThread = new MyThread();
myThread.start();

实现Runnable接口

class MyRunnable implements Runnable {public void run() {System.out.println("MyRunnable running");}
}Thread thread = new Thread(new MyRunnable());
thread.start();

Thread类和Runnable接口是创建线程的主要方式。

18. 同步

同步机制确保在多线程环境中对共享资源的安全访问。

public class Counter {private int count = 0;public synchronized void increment() {count++;}public synchronized int getCount() {return count;}
}

synchronized关键字确保一次只有一个线程可以执行方法体内的代码。

19. 高级多线程

使用ExecutorService和Future可以更方便地管理线程池和异步任务。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;ExecutorService executor = Executors.newFixedThreadPool(2);executor.submit(() -> {System.out.println("ExecutorService running");
});executor.shutdown();