class ClassName extends SuperClass{
//
}
interface InterfaceName extends /*[interface列表]*/{
//
}
在 java 语言中，class 是单继承，extends 关键字后只能有一个类名，即只能有一个直接父类；interface 是单继承，extends 关键字后可以有多个 interface 名称。
如果一个类定义时没有使用 extends 关键字，则它的超类是 Object 类
Object类是Java中所有类的根类，它定义了一些通用的方法，如toString()、equals()、hashCode()等。因此，所有的Java类都最终是Object类的子类，直接或间接地。
子类的代码中，可以直接访问所有符合访问控制规则的超类中的成员。
子类的构造方法总会调用超类的构造方法。如果在子类的构造方法中，没有调用超类构造方法的语句，则编译器会插入调用超类无参构造方法的语句。
子类中明确调用超类构造方法时，使用 super 关键字。
需要时，子类中可以使用 super 关键字访问超类的成员变量或者成员方法。
可以把子类对象赋值给超类类型的变量。（向上转型）
可以使用子类类型的变量访问超类中符合访问规则的成员
如果把子类对象赋值给超类类型变量，则不能使用超类类型变量访问只在子类中定义的成员’
不属于和超类同一包中的类，无法通过子类变量来访问 protected 成员。
protected 成员。protected 的成员。protected 成员。final class ClassName {…}，则该类不能被继承
重载：同一个类中多个方法具有相同的方法名，参数列表不同
覆盖：指子类中重新定义超类中已有的一个或者多个方法/以及实现接口中的方法。
publicfinal关键字，则该方法不能被覆盖。隐藏：子类中定义了与超类中同名的成员变量，默认情况下，这个变量名指代子类的成员变量，称该超类变量被隐藏。
覆盖所产生的多态效应，特别的是指在变量为某超类类型，而实际对象为其子类对象时，调用被覆盖方法，执行实际对应子类对象方法。
Object 类是所有类的超类，因为所有类都是直接或间接继承自它。
Object 类中重点关注的方法:
控制台
输出：
System.out.println//打印输出并换行
System.out.printf//格式化输出
System.out.print//打印输出不换行
输入：
Scanner input = new Scanner(System.in);
//intput.nextXXX
String userInput = input.nextLine(); // 读取用户输入的一行字符串
int userNumber = input.nextInt(); // 读取用户输入的整数
input.close()
Files
//Path path = Path.of(<filepath>);
String content = "Hello,wotld!";
//Files.writeString(path,content);
//Files.writeString(path,content,StandardOpenOption.APPEND);
//Files.writeString(path,content,Charset.forName("UTF-8"),StandardOpenOption.APPEND);
PrintWriter
PrintWriter out = new PrintWriter("filename.txt","UTF-8");//Charset.forName("UTF-8")
//out.println
//out.printf
//out.print
//write,write(String s)
out.close();
异常：在程序运行中发生的，导致程序不能正常执行的事件对象 Error 类和Exception类都继承自Throwable类，RuntimeException类是Exception类的子类
三种异常
抛出异常的关键字：throw ExceptionObj
异常处理原则：捕获或者声明
对于编译时检查，必须编写应对可能抛出的异常。有两种方式：
第一种捕获异常的句式(try-catch-[finally]):
try{
......
......
}catch(ExceptionType1 ex){
......
.......
}catch((ExceptionType2 ex){
......
........
}catch((ExceptionTypeN ex){
.....
....
}catch(Exception1|Exception2|ExceptionN ex){
...
.....
}
//[如果有类似文件等资源需要释放，添加finally子句
finally{
//finally块中的代码无论是否发生异常，都会执行。
//资源释放代码
}
第二种捕获异常句式（try-with-resources）
//try-with-resources 句式中，try()之间可以创建多个I/O对象（比如，有时同时需要读、写文件），中间用“;”
try(StreamType1 objRef1 = new StreamType1(...);
StreamType2 objRef2 = new StreamType2(....)){
}catch(ExceptionType1 ex){
......
.......
}catch((ExceptionType2 ex){
......
........
}catch((ExceptionTypeN ex){
.....
....
}catch(Exception1|Exception2|ExceptionN ex){
...
.....
}
//[如果有其他非I/O流资源需要释放，添加finally子句
finally{
//finally块中的代码无论是否发生异常，都会执行。
//资源释放代码
}
可以通过继承 Exception 类创建自定义异常，使用 throw 关键字抛出
catch 语句是按照编码顺序进行匹配，所以，多个catch子句包含子类和父类异常时，子类catch语句应在前
finally子句总是被执行，所以应在finally子句中释放资源
try块中定义的变量在catch子句中无法访问
子类覆盖方法时，不能添加异常
如果自定义的方法中，有代码可能抛出 checked 异常，如果没有使用 try-catch 语句捕获，方法定义时必须使用 throws 关键字声明这些 checked 异常 vod method() throws exception1,exception2(...)
调用可能抛出异常的方法可以捕获，或者再次声明throws
进程：内存等计算资源分配单位（文件句柄）
线程：CPU 调度单位
并发： 并发是指多个任务在一段时间内同时执行，可能是交替执行，但在宏观上看起来是同时的。在并发模型中，多个任务可以在同一个时间段内启动、执行和完成。
并行：并行是指多个任务在同一时刻同时执行。在并行计算中，多个处理器或核心可以同时执行多个任务，提高计算速度。
并行是并发的一种特例
1. 继承 Thread 类
class Task extends Thread{
public void run(){
//
}
}
Thread taskRef = new Task();
taskRef.start();
2. 实现 Runnable 接口
class Task implements Runnable{
public void run(){
//
}
}
Thread taskRef = new Thread(new Task());
taskRef.start();
public class HelloWorld{
public static void main(String[] args){
system.out.println("Hello world!");
}
}
import javax.swing.*;
public class EmptyWindow extends JFrame{
public EmptyWindow(){
setSize(1024,768);//设置窗口大小
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
public static void main(String[] args){
SwingUtilies.invokeLater(
()->{
JFrame frame = new EmptyWindow();
frame.setVisible(true);//显示窗口
}
);
}
}
import javax.swing.*;
public class AddComponentDemo extends JFrame{
public AddComponentDemo(){
setSize(800,600);//设置窗口大小
//确保点击窗口关闭按钮时，程序能正常退出
setDefaultCloseOperation(EXIT_ON_CLOSE);
initComponents();
}
private void initComponents(){
inputField = new JTextField(); //创建输入框
//输入框左上角坐标（500，500），宽度180，高度25
inputField.setBounds(500,500,180,25);
bt = new Jbutton("按钮")； //创建按钮
//按钮左上角坐标（700，500），宽度60，高度25
bt.setBounds(700,500,60,25);
setLayout(null); //为了使得 setBound 能够正常工作，需要设置布局管理器为 null
add(bt); //添加按钮组件
add(inputField); //添加文本输入框组件
}
public static void main(String[] args){
SwingUtilities.invokeLater(
()->{
JFrame frame = new AddComponentDemo();
frame.setVisible(true);//显示窗口
}
)；
}
private JButton bt;
private JTextField inputField;
}
import javax.swing.*;
public class AddComponentDemo extends JFrame {
private JButton bt;
private JTextField inputField;
public AddComponentDemo() {
setSize(800, 600); // 设置窗口大小
setDefaultCloseOperation(EXIT_ON_CLOSE); // 设置点击窗口关闭按钮时程序能正常退出
initComponents(); // 初始化组件
}
private void initComponents() {
inputField = new JTextField(); // 创建文本输入框
// 设置输入框左上角坐标（500，500），宽度180，高度25
inputField.setBounds(500, 500, 180, 25);
bt = new JButton("按钮"); // 创建按钮
// 设置按钮左上角坐标（700，500），宽度60，高度25
bt.setBounds(700, 500, 60, 25);
setLayout(null); // 为了使得 setBounds 能够正常工作，需要设置布局管理器为 null
add(bt); // 添加按钮组件
add(inputField); // 添加文本输入框组件
}
public static void main(String[] args) {
SwingUtilities.invokeLater(
() -> {
JFrame frame = new AddComponentDemo();
frame.setVisible(true); // 显示窗口
}
);
}
}
AddComponentDemo 类： 继承自 JFrame 类，表示一个窗口。
initComponents 方法： 初始化窗口中的组件，包括文本输入框和按钮。通过 setBounds 方法设置组件的位置和大小，通过 setLayout(null) 禁用布局管理器，使得 setBounds 能够正常工作。
main 方法： 使用 SwingUtilities.invokeLater 来确保窗口在事件分派线程上创建，避免多线程问题。创建 AddComponentDemo 的实例并显示窗口。
// 添加按钮组件
add(inputField); // 添加文本输入框组件
}
public static void main(String[] args) {
SwingUtilities.invokeLater(
() -> {
JFrame frame = new AddComponentDemo();
frame.setVisible(true); // 显示窗口
}
);
}
}
1. **`AddComponentDemo` 类：** 继承自 `JFrame` 类，表示一个窗口。
2. **`initComponents` 方法：** 初始化窗口中的组件，包括文本输入框和按钮。通过 `setBounds` 方法设置组件的位置和大小，通过 `setLayout(null)` 禁用布局管理器，使得 `setBounds` 能够正常工作。
3. **`main` 方法：** 使用 `SwingUtilities.invokeLater` 来确保窗口在事件分派线程上创建，避免多线程问题。创建 `AddComponentDemo` 的实例并显示窗口。
4. **`bt` 和 `inputField`：** 分别表示按钮和文本输入框的实例变量，可以在类的其他方法中使用。