随笔——重温Java基础语法

温故而知新

• JVM、JRE、JDK
• 创建项目，模块，包和类
• 基本数据类型boolean、byte、short、char、int、long、float、double
• 异或运算符，相同则假

true ^ false (结果为true)

true ^ true (结果为false)

• 三目运算符：a > b ? a+1 : 666

• Java 数组的本质

int[] arr = new int[]{1, 6, 2, 8};
int[] arr = {1, 6, 2, 8};
类比
String str = new String("张三");
String str = "张三";

Java中的数组其实是一个对象，但是确实是一个特殊的对象，实在是太特殊了，以致我们都不好把它多做对象处理。

java对数组对象化的操作的支持是指令级的，也就是说java虚拟机有专门针对数组的指令。数组的Class类实例是java虚拟机动态创建动态加载的，其结构与普通java类的Class实例有一些不同。

• Python 的函数是支持默认参数的，而 Java 的方法是不支持默认参数的，但是 Java 可以通过重载方法实现类似的功能。

重载方法：看入不看出（即：只看方法的入口，不看方法的出口。方法的入口指的是"方法名称，参数列表"；方法的出口指的是”返回值“；修饰符就更加无关紧要了）

• Java 类的属性和方法访问权限

不写修饰符，访问权限默认是 不填 级别，即同一空间环境下类之间可以互相访问（类的同一空间环境指的是"在同一个包下"）
不填 级别处于中间位置，前可攻，退可守；
当它前进一步时，即使用public或protected修饰符，可扩大访问权限。
当它后退一步时，即使用private修饰符，可缩小访问权限。

• 静态代码块

static {
	...
}

// 特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次

• 实例代码块

{
	...
}

// 特点：每次创建对象时，执行实例代码块，并在构造器之前执行

• Java 不支持多继承，而 Python 支持多继承
• Object类是java所有类的祖宗类
• 输出对象时，默认会调用toString()方法
• 在执行子类的构造器时，子类的全部构造器，都会先调用父类的构造器，再执行自己的构造器（默认第一行就是super()）
• 兄弟构造器

public class Student{
	private String name;
	private int age;
	private String schoolName;
	
	
	public Student(String name, int age){
		this(name, age, "野鸡学校");	// 调用兄弟构造器
	}
	
	public Student(String name, int age, String schoolName){
		this.name = name;
		this.age = age;
		this.schoolName = schoolName;
	}
}

• 多态存在的问题：无法直接调用子类独有的功能，需要借助类型转换才能实现

• 在类中，如果需要类型转换，建议使用 instanceof 关键字，判断当前对象的真实类型，再进行强转。

• 抽象类可以像普通类一样，写很多东西。

• Jdk8之前 接口 只能在里面写"常量"和"抽象方法"，接口比抽象类更抽象（即：更严格）

public interface A {
	// 成员变量（自动变成常量）
	String NAME = "Jack";
	
	// 成员方法（自动变成抽象方法）
	void test();
}

• jdk8之后 接口 新增方法

public interface A {
	// 1.默认方法
	// 必须使用default修饰，默认会被public修饰
	// 可以写方法体
	// 必须使用实现类所创建的对象进行访问
	default void test1(){
		System.out.println("==默认方法==");
	}
	
	// 2.私有方法
	// 必须使用private修饰（jdk9开始支持）
	// 必须在接口里面进行访问，比如默认方法里面可以调用
	private void test2(){
		System.out.println("==私有方法==");
	}
	
	// 3.静态方法
	// 必须使用static修饰，默认会被public修饰
	// 直接通过   接口名.方法名   进行访问
	static void test3(){
		System.out.println("==静态方法==");
	}
	
}

• 接口 可以多继承

interface A {}
interface B {}
interface C {}

// 接口是多继承的
interface D extends C, B, A {
	
}

// 接口多继承的意义
// class People implements C, B, A {}
// 上面的代码可直接写成下面的代码
class People implements D {}

• 抽象方法和接口都可以使用匿名内部类语法

• 如果匿名内部类满足一定条件，可以简化成 lambda 表达式

• 适当使用枚举，去约束输入的内容

• 学习集合

  • Collection 接口

    • List 接口
      • ArrayList 实现类
      • LinkedList 实现类
    • Set 接口
      • HashSet 实现类（底层原理是 HashMap ）
      • LinkedHashSet 实现类（底层原理是 LinkedHashMap ）
      • TreeSet 实现类（底层原理是 TreeMap ）

  • Map 接口

    • HashMap 实现类
    • LinkedHashMap 实现类
    • TreeMap 实现类

  • 集合 stream 化

• 可变参数

int func(int age, int... nums){
	// 只能有一个可变参数
	// 可变参数要放到最后
	// 可变参数本质就是数组
}

func(10)				// 可变参数没有数据
func(10, 20, 30, 40);	// 可变参数数据为：20,30,40
func(10, new int[]{20,30,40})

• IO 流
• 字节流（操作图片、视频、文件）
  • InputStream 抽象类
    • FileInputStream 具体类
    • 其他具体类
  • OutputStream 抽象类
    • FileOutputStream 具体类
    • 其他具体类
• 字符流（操作文本文件、Java文件）
  • Reader 抽象类
    • FileReader 具体类
    • 其他具体类
  • Writer 抽象类
    • FileWriter 具体类
    • 其他具体类
• 日志技术
• JCL 接口（Jakarta Commons Logging）
  • JUL 实现框架（java.util.logging）
• slf4j 接口（simple logging facade for java）
  • Log4j 实现框架
  • Logback 实现框架
• 多线程
• 通过CAS算法（Compare And Swap）实现乐观锁。其本质通过消耗计算资源，去实现"无锁数据结构"，进而减少锁带来的开销。
• CAS算法基本原理：CAS算法包含三个操作数——内存位置（V），预期值（A）和新值（B）。如果内存位置的值与预期值相匹配，就将内存位置的值修改为新值。这个操作是原子的，即不可中断。
• Junit单元测试框架，通过一些配置和写一些测试方法，能够非常方便的对方法进行测试。既能局部测试，又能全局测试。
• 反射
• 通过反射，可以动态操作已经定义好的类，获取类的属性和方法，进行进一步操作
• 反射非常强大，能够破环类的封装性，为所欲为
• 使用反射技术，可能代码稍微复杂，但是能够对代码进行反向的控制，通常利用它来制作框架。
• 注解
  • 使用 JD-GUI 反编译工具，对注解代码进行反编译，进而认识注解的本质是接口
  • 元注解是用来帮助我们更好的实现自定义的注解
  • 通过反射技术，解析注解，从而获取某些信息