【JAVA】56个要点知识梳理——容易忽略的基础

谁践踏了优雅 2022-01-21 08:57 270阅读 0赞

1.  Java具有平台无关性，用Java写的应用程序不经过修改就可以在不同的软硬件平台上运行。平台无关性有两种：源代码级和目标代码级。C/C++仅具有一定程度的源代码级平台无关性，而Java可以通过JVM（Java Virtual Machine，Java虚拟机）实现目标代码级的平台无关性。
2.  Java不支持指针。
3.  Java主要用于网络应用程序开发，具有较高的安全性。
4.  Java提供的多线程机制容易实现网上的实时交互行为。
5.  Java提供了URL（Uniform Resource Locator，统一资源定位符）和基于流套接字的网络编程接口。
6.  JDK（Java Development Kits，Java开发工具包）是Java的核心，包括了运行环境、工具和基本类库。
7.  输出：
    
        System.out.print();        // 输出一行
        System.out.println();      // 输出一行后换行
        System.out.printf();       // 格式化输出
8.  输入：
    
        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();                     // 键盘输入字符串
9.  Java的基本数据类型：布尔型boolean、字符型char、字节型byte、短整型short、整型int、长整型long、浮点型float、双精度浮点型double（从左到右为自动类型转换）。
10. Java是一种严格的类型语言，它不允许数值类型与布尔类型之间的转换。
11. Java的字符类型采用Unicode编码，无论是东方还是西方字符，都可以用一个字符表示。
12. Java中的默认初值：数值型（0）；布尔型（false）；字符型（"\\u0000"）；引用类型（null）
13. Java中字符型与整型之间的转换：
    
        // 字符型转整型
        int i = Integer.parseInt(str);
        int i = Integer.valueOf(str);
        
        // 整型转字符型
        String str = Integer.toString(i);
14. Java中的null为全小写。
15. Java的符号常量：
    
        // final 数据类型 变量名 = 默认值;
        final float PI = 3.14;
    
    顺带一提，“final”带有不可修改的意味，它在继承和多态中还会出现。
16. 编写Java程序时可能经常看到一个叫“args”的变量，它是“arguments”的缩写，只是一个默认名。
17. continue 与 break：continue语句只能出现在循环体中，其作用是结束本轮循环，然后判断是否进行下一轮循环；break语句仅出现在switch语句或循环体中，其作用是从switch语句的分支中跳出，或从循环体内部跳出。
18. 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);
        		}
        	}
        }
19. 逻辑与&&优先级高于逻辑或||
20. Java的类成员分别为：域（变量）、构造方法、方法
21. Java的类成员访问控制修饰符：public、private、package（默认值）、protected
22. Java的垃圾收集机制：Java允许在资源许可范围内创建任意个对象，当对象不再使用时会被自动清除。finalize()的作用与析构函数类似。System.gc()可显式运行垃圾收集程序。
23. 属于类的变量或方法称为静态变量或静态方法，使用static关键字。静态变量和方法在程序初始化运行时就加载到内存中，可以提高代码执行效率，但有可能增加内存负担。
24. Java中创建包，代码第一行：
    
        package PackageName;
        
        public class ClassName {
        
        }
25. Java中导入包（对于自定义的包，只有位于同一项目中的类才可以导入）：
    
        import PackageName.ClassName;    // 导入包中的某一个类
        
        import PackageName.*;            // 导入包的全部内容
26. Java中的类只支持单继承，而接口支持多继承。Java多继承的功能是通过接口方式来间接实现的。
27. 继承，使用关键字extends：
    
        public class ClassName extends BaBa_Class {
            public ClassName() {    
                super();            // 父类构造函数
                                    // 其余初始化内容
            }
        }
28. 重写（overriding）：子类定义了与父类中方法头相同的方法。若需要调用该父类方法，使用super.FunctionName()。
29. 构造方法的调用顺序是父类到子类，finalize()相反。
30. 可以将子类对象赋给父类变量，而不能调转过来。
31. 抽象类不能创建对象，但它可以创建引用变量，用以保存任何具体子类对象。
32. 每个抽象类至少包含一个抽象方法。抽象方法仅仅声明了功能的接口，并不提供功能的实现。抽象类的所有具体子类必须提供抽象方法的具体实现（从而实现多态性）。
    
        // 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);
        	}
        }
33. 接口由一组常量和一组抽象方法组成，不包括变量和具体方法的实现。接口中的成员可以不使用修饰符，因为全部都默认好了。
34. 接口与抽象类的区别：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);
        	}	
        }
35. Java中允许在一个类的内部定义另一个类，即嵌套类/内部类。内部类主要用于事件处理（后面GUI再提）。由于内部类嵌套在外部类中，作为外部类的一个成员，所以内部类可以使用外部类定义的所有成员。
36. 匿名内部类是指没有类名的内部类。定义匿名内部类的地方往往直接创建该类的对象：
    
        new ParentName() {
            // ParentName 是匿名内部类继承的父类名，或是实现的接口名
        }
37. 泛型集合类：Java的集合类，主要用于存放一组对象的引用变量集合，又称容器类 + 泛型思想，集合中的元素类型是通用的，封装在集合类中的常用算法也是通用的。如：Collection<>、Set<>、List<>、Map<>、Queue<>、Stack<>。
38. 异常处理：把所要监控的代码放进一个try块里，紧跟着的（一个或多个）catch子句进行异常捕捉和处理。
39. Java的异常是一个对象，所有异常都直接或间接地继承自Throwable类。Throwable类又可分为 Error 和 Exception 子类。用户自定义的异常一定继承自Throwable类或Exception类。
40. Java的异常处理是通过3个关键字来实现的：try、catch、finally（最终处理）。
41. 在try块中可以主动抛出（throw）异常：
    
        try {
            throw new ArrayIndexOutOfBoundsException();
        }
        catch(ArrayIndexOutOfBoundsException ai) {
            System.out.println(ai);
        }
42. 在方法头可以重新抛出（throws）异常：
    
        public void compute() throws ArithmeticException {
            // 方法体中可能抛出异常，但不作处理，而是将异常往上传递
        }
43. 用户自定义异常：
    
        class myException extends Exception {    // 自定义异常类
            public myException () {
                super();
            }
        }
        
        if(条件不符) {
            myException me = new myException("条件不符！");
            throw me;                            // 抛出异常
            
            // 其实也可以不自定义异常类
            throw new Exception("条件不符！");
        }
44. 进程空间大体分为数据区、代码区、栈区、堆区，多个进程的内部数据和状态是完全独立的；而线程共享进程的数据区、代码区、堆区，只有栈区是独立的，所以线程切换的代价比进程小。
45. 每个Java程序都有一个缺省的主线程，要实现多线程，必须在主线程中创建新的线程对象。
46. 一个线程完整的生命周期包括5个状态：
    
        // 创建状态：拥有内存空间及部分资源
        Thread myThread = new Thread();
        
        // 就绪状态：等待CPU
        // 阻塞状态的线程被接触阻塞后，进入就绪状态
        // 运行中的线程调用yield()，放弃CPU，进入就绪状态
        myThread.start();
        
        // 运行状态：线程对象被调度后自动执行
        Thread.run();
        
        // 阻塞状态之睡眠状态：等待睡眠时间结束进入就绪状态
        Thread.sleep();
        
        // 阻塞状态之等待状态：等待另一个线程调用notify()或notifyAll()
        wait();
        
        // 解除阻塞状态
        Thread.interrupt();
        
        // 死亡状态：执行完run()的最后一个语句
47. myThread.join()：中断当前运行的线程，优先处理myThread。
48. 实现多线程有两种方式：1.创建Thread类的子类；2.实现Runnable接口。Thread类是一个具体的类，它封装了一个线程需要的属性和方法；Runnable接口只有一个方法run()。
49. 第一种多线程方式（以三个不同时间间隔的闹钟为例）：
    
        // 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");
        	}
        
        }
50. 第二种多线程方式：
    
        public class Clock implements Runnable {        // 实现Runnable接口
        
            Thread clock;                               // 创建一个Thread对象
        
            clock = new Thread(this, "Clock_Thread");   // 将Clock实例作为参数传递给Thread对象
        
            void run() {
                clock.sleep(1000);                      // 通过clock调用Thread类方法
        	}
        }
51. 线程同步：synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号\{\}括起来的代码，作用的对象是调用这个代码块的对象；  
    2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；  
    3. 修饰一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；  
    4. 修饰一个类，其作用的范围是synchronized后面括号括起来的部分，作用的对象是这个类的所有对象。
52. （以下是Java GUI的知识）Java中用来生成图形用户界面（GUI）的类库主要在java.awt包和javax.swing包中。
53. AWT：组件（Component）是一个以图形化的方式显示在屏幕上并能与用户交互的对象；容器（Container）是Component的子类，add()向容器添加组件，remove()从容器移除组件，每个容器都与一个布局管理器相连；布局管理器（LayoutManager）用于管理组件在容器中的布局方式。
54. Swing：Swing是轻量级组件，组件名称都以“J”开头。顶层容器（如JFrame）、普通容器（如JPanel）。
55. 向顶层容器JFrame添加组件有两种方式：
    
        // 方法一：getContentPane().add();
        frame.getContentPane().add(component);
        
        // 方法二：setContentPane(JPanel);
        JPane contentPane = new JPanel();
        frame.setContentPane(contentPane);
56. 最后贴一个劣质计算器的代码，知识点都在注释里面哦~

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhMWZfQXdha2U_size_16_color_FFFFFF_t_70][]

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);
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hhMWZfQXdha2U_size_16_color_FFFFFF_t_70]: /images/20220121/523650533bda463aa3c87797ca6f38d7.png