【JAVA】56个要点知识梳理——容易忽略的基础-优快云博客

本文梳理了Java的重要知识点，包括平台无关性、不支持指针、安全性、多线程机制、网络编程接口、JDK、基本数据类型、类型转换规则、变量与方法、类的访问控制修饰符、垃圾收集机制、静态成员、包和导入、继承与接口、异常处理、多线程、线程同步、以及GUI和GUI组件等核心概念。

Java具有平台无关性，用Java写的应用程序不经过修改就可以在不同的软硬件平台上运行。平台无关性有两种：源代码级和目标代码级。C/C++仅具有一定程度的源代码级平台无关性，而Java可以通过JVM（Java Virtual Machine，Java虚拟机）实现目标代码级的平台无关性。
Java不支持指针。
Java主要用于网络应用程序开发，具有较高的安全性。
Java提供的多线程机制容易实现网上的实时交互行为。
Java提供了URL（Uniform Resource Locator，统一资源定位符）和基于流套接字的网络编程接口。
JDK（Java Development Kits，Java开发工具包）是Java的核心，包括了运行环境、工具和基本类库。

输出：

System.out.print();        // 输出一行
System.out.println();      // 输出一行后换行
System.out.printf();       // 格式化输出

输入：

import java.util.Scanner;                // 导入Scanner包

Scanner sc = new Scanner(System.in);     // 实例化Scanner类对象

int num = sc.nextInt();                  // 键盘输入整型
int name = sc.nextLine();                // 键盘输入字符串

// 以上两种可以同一行空格间隔输入
// 而sc.next需要换行输入，建议输入字符串使用next()

int sex = sc.next();                     // 键盘输入字符串

Java的基本数据类型：布尔型boolean、字符型char、字节型byte、短整型short、整型int、长整型long、浮点型float、双精度浮点型double（从左到右为自动类型转换）。
Java是一种严格的类型语言，它不允许数值类型与布尔类型之间的转换。
Java的字符类型采用Unicode编码，无论是东方还是西方字符，都可以用一个字符表示。
Java中的默认初值：数值型（0）；布尔型（false）；字符型（"\u0000"）；引用类型（null）

Java中字符型与整型之间的转换：

// 字符型转整型
int i = Integer.parseInt(str);
int i = Integer.valueOf(str);

// 整型转字符型
String str = Integer.toString(i);

Java中的null为全小写。
Java的符号常量：
```
// final 数据类型 变量名 = 默认值;
final float PI = 3.14;
```
顺带一提，“final”带有不可修改的意味，它在继承和多态中还会出现。
编写Java程序时可能经常看到一个叫“args”的变量，它是“arguments”的缩写，只是一个默认名。
continue 与 break：continue语句只能出现在循环体中，其作用是结束本轮循环，然后判断是否进行下一轮循环；break语句仅出现在switch语句或循环体中，其作用是从switch语句的分支中跳出，或从循环体内部跳出。

Java的foreach循环

public class foreach {

	public static void main(String[] args) {

		String strs[];                    // 声明字符串数组
		strs = new String[3];             // 分配数组空间
	
		strs[0] = new String("first");	  // 逐个数组元素赋值
		strs[1] = new String("second");
		strs[2] = new String("third");
		
		for(String element: strs) {       // foreach循环
			System.out.printf("%s\n", element);
		}
	}
}

逻辑与&&优先级高于逻辑或||
Java的类成员分别为：域（变量）、构造方法、方法
Java的类成员访问控制修饰符：public、private、package（默认值）、protected
Java的垃圾收集机制：Java允许在资源许可范围内创建任意个对象，当对象不再使用时会被自动清除。finalize()的作用与析构函数类似。System.gc()可显式运行垃圾收集程序。
属于类的变量或方法称为静态变量或静态方法，使用static关键字。静态变量和方法在程序初始化运行时就加载到内存中，可以提高代码执行效率，但有可能增加内存负担。

Java中创建包，代码第一行：

package PackageName;

public class ClassName {

}

Java中导入包（对于自定义的包，只有位于同一项目中的类才可以导入）：

import PackageName.ClassName;    // 导入包中的某一个类

import PackageName.*;            // 导入包的全部内容

Java中的类只支持单继承，而接口支持多继承。Java多继承的功能是通过接口方式来间接实现的。

继承，使用关键字extends：

public class ClassName extends BaBa_Class {
    public ClassName() {    
        super();            // 父类构造函数
                            // 其余初始化内容
    }
}

重写（overriding）：子类定义了与父类中方法头相同的方法。若需要调用该父类方法，使用super.FunctionName()。
构造方法的调用顺序是父类到子类，finalize()相反。
可以将子类对象赋给父类变量，而不能调转过来。
抽象类不能创建对象，但它可以创建引用变量，用以保存任何具体子类对象。

每个抽象类至少包含一个抽象方法。抽象方法仅仅声明了功能的接口，并不提供功能的实现。抽象类的所有具体子类必须提供抽象方法的具体实现（从而实现多态性）。

// Person.java
public abstract class Person{            // 抽象类
	
	public abstract void getName();      // 抽象方法
	
	public void getNo() {
		System.out.print("null");
	}
}

// CollegeStudent.java
public class CollegeStudent extends Person {

	private String name = "test";
	
	@Override
	public void getName() {
		System.out.println(this.name);
	}
}

接口由一组常量和一组抽象方法组成，不包括变量和具体方法的实现。接口中的成员可以不使用修饰符，因为全部都默认好了。

接口与抽象类的区别：1.接口不能实现任何方法，而抽象类可以；2.一个类可以实现多个接口，但只能继承一个超类。先继承，后实现接口，多个接口间用逗号间隔。

// Person.java
public interface Person {           //定义接口
	
	public abstract void getName();	//修饰符可以省略	
}

// CollegeStudent.java
public class CollegeStudent implements Person {    // 实现接口

	private String name = "test";
	
	@Override
	public void getName() {
		System.out.println(this.name);
	}	
}

Java中允许在一个类的内部定义另一个类，即嵌套类/内部类。内部类主要用于事件处理（后面GUI再提）。由于内部类嵌套在外部类中，作为外部类的一个成员，所以内部类可以使用外部类定义的所有成员。
匿名内部类是指没有类名的内部类。定义匿名内部类的地方往往直接创建该类的对象：
```
new ParentName() {
    // ParentName 是匿名内部类继承的父类名，或是实现的接口名
}
```
泛型集合类：Java的集合类，主要用于存放一组对象的引用变量集合，又称容器类 + 泛型思想，集合中的元素类型是通用的，封装在集合类中的常用算法也是通用的。如：Collection<>、Set<>、List<>、Map<>、Queue<>、Stack<>。
异常处理：把所要监控的代码放进一个try块里，紧跟着的（一个或多个）catch子句进行异常捕捉和处理。
Java的异常是一个对象，所有异常都直接或间接地继承自Throwable类。Throwable类又可分为 Error 和 Exception 子类。用户自定义的异常一定继承自Throwable类或Exception类。
Java的异常处理是通过3个关键字来实现的：try、catch、finally（最终处理）。

在try块中可以主动抛出（throw）异常：

try {
    throw new ArrayIndexOutOfBoundsException();
}
catch(ArrayIndexOutOfBoundsException ai) {
    System.out.println(ai);
}

在方法头可以重新抛出（throws）异常：

public void compute() throws ArithmeticException {
    // 方法体中可能抛出异常，但不作处理，而是将异常往上传递
}

用户自定义异常：

class myException extends Exception {    // 自定义异常类
    public myException () {
        super();
    }
}

if(条件不符) {
    myException me = new myException("条件不符！");
    throw me;                            // 抛出异常
    
    // 其实也可以不自定义异常类
    throw new Exception("条件不符！");
}

进程空间大体分为数据区、代码区、栈区、堆区，多个进程的内部数据和状态是完全独立的；而线程共享进程的数据区、代码区、堆区，只有栈区是独立的，所以线程切换的代价比进程小。
每个Java程序都有一个缺省的主线程，要实现多线程，必须在主线程中创建新的线程对象。

一个线程完整的生命周期包括5个状态：

// 创建状态：拥有内存空间及部分资源
Thread myThread = new Thread();

// 就绪状态：等待CPU
// 阻塞状态的线程被接触阻塞后，进入就绪状态
// 运行中的线程调用yield()，放弃CPU，进入就绪状态
myThread.start();

// 运行状态：线程对象被调度后自动执行
Thread.run();

// 阻塞状态之睡眠状态：等待睡眠时间结束进入就绪状态
Thread.sleep();

// 阻塞状态之等待状态：等待另一个线程调用notify()或notifyAll()
wait();

// 解除阻塞状态
Thread.interrupt();

// 死亡状态：执行完run()的最后一个语句

myThread.join()：中断当前运行的线程，优先处理myThread。
实现多线程有两种方式：1.创建Thread类的子类；2.实现Runnable接口。Thread类是一个具体的类，它封装了一个线程需要的属性和方法；Runnable接口只有一个方法run()。

第一种多线程方式（以三个不同时间间隔的闹钟为例）：


// Clock.java
public class Clock extends Thread {
	
	// 当前时间
	public int curTime = 0;
	
	// 1000毫秒，即1秒
	public int interval = 1000;
	
	// interval的倍数，不同时钟倍数不同
	public int times;
	
	// 定义构造方法
	public Clock (String name, int times) {
		super(name);
		this.times = times;
	}
	
	// run()
	public void run () {
		try {
			// 显示35秒
			for (int i = 0; i < 35 * interval; i += 1000) {
				
				System.out.println(this.getName() + " 当前运行时间为 " + this.curTime/1000 + "秒");
				
				// 时间增加，等待唤醒
				this.curTime += this.interval * this.times;
				
				// 睡眠：间隔多少秒就睡多久
				Thread.sleep(this.interval * this.times);
			}
		}
		catch (InterruptedException e) {
			// 唤醒，显示更新后的时间
		}
	}
}

// DisplayClocks.java
public class DisplayClocks {

	public static void main(String[] args) {
		
		Clock clk1 = new Clock("间隔1秒的闹钟", 1);
		Clock clk2 = new Clock("间隔5秒的闹钟", 5);
		Clock clk3 = new Clock("间隔10秒的闹钟", 10);

		System.out.println("主线程将要启动三个闹钟");
		
		clk1.start();
		clk2.start();
		clk3.start();
		
		System.out.println("三个闹钟启动完成，主线程运行结束\n");
	}

}

第二种多线程方式：

public class Clock implements Runnable {        // 实现Runnable接口

    Thread clock;                               // 创建一个Thread对象

    clock = new Thread(this, "Clock_Thread");   // 将Clock实例作为参数传递给Thread对象

    void run() {
        clock.sleep(1000);                      // 通过clock调用Thread类方法
	}
}

线程同步：synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
3. 修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
4. 修饰一个类，其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象。
（以下是Java GUI的知识）Java中用来生成图形用户界面（GUI）的类库主要在java.awt包和javax.swing包中。
AWT：组件（Component）是一个以图形化的方式显示在屏幕上并能与用户交互的对象；容器（Container）是Component的子类，add()向容器添加组件，remove()从容器移除组件，每个容器都与一个布局管理器相连；布局管理器（LayoutManager）用于管理组件在容器中的布局方式。
Swing：Swing是轻量级组件，组件名称都以“J”开头。顶层容器（如JFrame）、普通容器（如JPanel）。

向顶层容器JFrame添加组件有两种方式：

// 方法一：getContentPane().add();
frame.getContentPane().add(component);

// 方法二：setContentPane(JPanel);
JPane contentPane = new JPanel();
frame.setContentPane(contentPane);

最后贴一个劣质计算器的代码，知识点都在注释里面哦~


import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Calculator extends JFrame {

	// 声明GUI组件
	private JLabel tips;
	private JTextField num1;
	private JTextField num2;
	private JButton calBt;
	private JTextArea result;
	
	// 定义构造方法
	public Calculator () {
		
		// 父类构造方法，窗口命名
		super("自定义计算器");
		
		// 获取内容面板
		Container container = getContentPane();
		// 设置面板布局
		container.setLayout(new FlowLayout(0,10,30));
		
		// 实例化组件
		tips = new JLabel("请输入两个整型数据：");
		num1 = new JTextField(10);
		num2 = new JTextField(10);
		calBt = new JButton("计算");
		result = new JTextArea(10,10);
		
		// 向面板添加组件
		container.add(tips);
		container.add(num1);
		container.add(num2);
		container.add(calBt);
		container.add(result);
		
		// 计算结果文本域不可编辑
		// result.setEditable(false);
		
		// 设置按钮点击事件
		ButtonDown btd = new ButtonDown();
		
		// 注册事件监听器
		calBt.addActionListener(btd);
		
		// 其余界面设置
		setSize(700,300);
		setVisible(true);
		
	}
	
	// 内部类
	// 定义按钮（事件源）点击事件，实现 ActionListener 接口
	private class ButtonDown implements ActionListener {
		
		public void actionPerformed (ActionEvent event) {	// 获取 ActionEvent 事件对象
			
			// 获取两个输入的数字
			int a = Integer.parseInt(num1.getText());
			int b = Integer.parseInt(num2.getText());
			
			// 五种计算结果
			int plus = a + b;
			int minus = a - b;
			int mul = a * b;
			int divide = a / b;
			int surplus = a % b;
			
			// 多行文本域的计算结果文本
			String text = num1.getText() + " + " + num2.getText() + " = " + Integer.toString(plus) + '\n' + 
						  num1.getText() + " - " + num2.getText() + " = " + Integer.toString(minus) + '\n' + 
						  num1.getText() + " * " + num2.getText() + " = " + Integer.toString(mul) + '\n' + 
						  num1.getText() + " / " + num2.getText() + " = " + Integer.toString(divide) + '\n' + 
						  num1.getText() + " % " + num2.getText() + " = " + Integer.toString(surplus) + '\n' ;
			
			result.setText(text);
					
		}
	}
	
	public static void main (String args[]) {
		Calculator calculator = new Calculator();
		calculator.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
}