1.数据类型
1.1基本数据类型 (注意字符串在java中属于引用类型)
数值型 整数类型（byte、short、int(4个字节，约21亿，范围 -2的31次方——2的31次方)、long(8个字节)）+ 浮点型（float、double） 字符型 (char) 布尔型(boolean)
1.2引用数据类型
注意：虽然字符串以及包装类属于引用类型，但是他们传递赋值过程简单记忆为值传递。改变一方不会影响另外一方。(由于String类和包装类都没有提供value对应的setter方法，我们无法改变其内容，所以导致我们看起来好像是值传递)
数组 类（class、字符串、Map等） 接口
2.数据间的运算转换
2.1基本数据：自动类型提升，容量小的和容量大的做运算，自动提升为容量大的数据类型。
byte --> short--->int--->long--->float--->double
2.2 基本数据：强制类型转换，当大容量的转换成小容量的数据时，需要强转，可能会导致精度损失。
double d = 12.98;
int i = (int)d; //12
2.3 引用数据类型：子类---（多态）--> 父类 ； 父类---（先instanceof判断 再向下转型）--> 子类
2.4 String类型和基本数据类型可以做拼接运算，运算结果是String类型。
3.数组
3.1 数组一旦初始化完成，其长度是确定的。
int [] arr = new int [5];
String [] arr1 = new String []{"bwf", "wmy"}
3.2 数组元素的默认初始化值
// 整型数组 默认初始化值是0
int [] arr = new int [5];
arr[0] //0
//引用类型数组 默认初始化值是null (空)
String [] arr1 = new String [5];
arr1[0] // null
4.类中的属性和局部变量不同点
4.1声明位置不同，属性直接定义在类内部，二局部变量定义在方法内、方法形参、代码块内、构造器内部的变量
4.2 属性可以使用权限修饰符（public private等），局部变量不行
4.3默认初始化化值
/**
* 属性：有默认初始化值
* int型 初始化值 ： 0
* 引用类型(如 String) 初始化值 ： null
* 局部变量：使用之前必须要先声明赋值
*/
/**
*属性赋值先后顺序：默认初始化--》显示初始化--》构造器中赋值--》对象.方法\对象.属性赋值
*后面的赋值方式会覆盖前面的赋值方式
*/
5.类中方法（类中结构主要有 属性、方法、构造器、代码块、内部类）
5.1 重载overload 和重写override 区别
/**
* 重载：同一个类中同一个方法名参数列表不同（参数列表：参数类型不同或者参数个数不同）
* 重写：子类继承父类以后，子类对父类方法进行重写（和父类中被重写方法 方法名和参数列表一样），实现了覆盖。子类重写的方法的返回值可以是父类被重写方法的返回值的子类。
*/
5.2 方法的可变形参，而且可变形参只能放在方法参数的末尾
public void show(String ... names){
// names 是一个数组
}
5.3 参数赋值
//形参若是基本数据类型，赋值过程是将实参的数据值传递给形参，改变形参不会影响实参
//形参若是引用数据类型，赋值过程是将实参的地址值传递给形参，改变形参会影响实参
//注意点：String类虽然是引用类型，但比较特殊，赋值过程是值传递。
@Test
public void test() {
String name1 = "wmy";
say(name1);
log.info("name1:{}",name1); //wmy 不会随着改变
String name2 = name1;
name2 = "xxx";
log.info("name1:{}",name1); //wmy 不会随着改变
}
public void say(String name) {
name = "bwf";
}
6.面向对象三大特征（封装性、继承性、多态性）
6.1封装性
//private: 类内部可见
//缺省: 同一个包可以见
//protected: 不同包的子类可见
//public: 同一个工程可用
// 四种权限修饰符类的内部结构（属性、方法、构造器、内部类）
// 修饰类只能用 public、缺省
6.2继承性extends
//所以的类直接或间接的继承Object类
// this 和 super
/**
* this.属性（方法） 先从自身去找，没找到，再去父类中找。
* super.属性（方法）直接去父类中找
* 一般属性或方法省略不写，就默认省略了 this
* this(形参列表)：本类中重载的其他的构造器
* super(形参列表)：父类中重载的构造器
* 在构造器中的首行没有显示声明this(形参列表)，super(形参列表)，则默认super()
*/
//
6.3多态性, 子类对象赋值给父类的引用。编译看左边，执行看右边子类有无重写父类的方法，若有，执行的是子类的方法；若无则执行的是父类中的方法。
@Test
public void test() {
Person p = new Student();
p.say(); //Student---say
p.eat(); //Person---eat
log.info(p.name); // person 多态性不适用于属性，属性始终看的左边父类中的属性。
//p.show(); Person这个引用类中没有show方法会报错（虽然子类中有）
}
class Person{
String name = "person";
void say(){
log.info("Person---say");
}
void eat(){
log.info("Person---eat");
}
}
class Student extends Person{
String name = "Student";
void say(){
log.info("Student---say");
}
void show(){
log.info("Student---show");
}
}
7. == 和 equals
public void test() {
// == 如果比较基本数据类型，则比较值是否相同（会存在自动类型提升）
int i = 10;
double d = 10.00;
log.info("i == d:{}", i == d); // true
// == 如果比较引用数据类型，则看的是地址是否一样
Person p1 = new Person();
Person p2 = new Person();
log.info("p1 == p2:{}", p1 == p2); // false
// Object类中equals方法，用的是 ==，比较的是两个对象的地址。
// 像@Data注解 String、Date、包装类、File 等常用类对Object类中equals方法进行重写，重写后比较的是两个对象的内容是否相同
log.info("p1.equals(p2):{}", p1.equals(p2)); // true
String a = "a";
String b = "a";
log.info("a.equals(b):{}", a.equals(b)); // true
//总结，对应基本数据类型常用 == 比较， 对应引用类型比较，常用两个类重写的equals()方法比较内容
}
@Data
class Person {
String name = "person";
}
8. 包装类以及和String类型间的相互转换
int----->Integer
boolean--->Boolean
@Test
public void test() {
// 属性默认值： 基本数据类型 和 引用数据类型的初始者不同
Person p = new Person();
log.info("int:{}", p.a); //0
log.info("Integer:{}", p.b); //null
//自动装箱和自动装箱
int i = 22;
Integer i1 = i;
int i2 = i1;
/**
*基本数据类型（包装类）------》String
* 1.采用字符串拼接
* 2.采用 String.valueOf()
*/
/**
*String------》基本数据类型（包装类）
* 1. 调用包装类的.parseXXX()
*/
String aa = "123";
int bb = Integer.parseInt(aa); //无法转化成有效数值则会报错 123
String b1 = "TRUE";
boolean b2 = Boolean.parseBoolean(b1);
log.info("b2:{}", b2); //true 只要忽略大小写是true即结果是true, 否则是false
}
9. static关键字 修饰 属性、方法、代码块
9.1static关键字修饰属性、方法
//1.static修饰的属性、方法随着类的加载而加载，可以通过 类.静态属性 、实例.静态属性 调用，且被多个实例共享一份。
//2.由于类只会加载一次，所以静态属性、方法在内存中也只有一份，存在方法区的静态域中
//3.在一个类中，静态方法里面只能调用静态属性、静态方法（此时调用的属性、方法前面省略了类. ）；非静态方法可以调用静态方法、非静态方法。
9.2 static关键字修饰代码块
//1.静态代码块：随着类的加载而执行，而且只执行一次。非静态代码块随着对象创建而执行多次。
//2.一个类中可以定义多个静态和非静态代码块，执行顺序跟定义先后顺序有关。
10. final关键字 修饰 类、方法、变量（包括局部变量+属性）
//1.final修饰类: 表示该类不可以再被继承，比如String类
//2.final修饰方法：表示该方法不可以被子类重写
//3.final修饰属性：该属性是一个常量，赋值的位置有：显示初始化、代码块初始化、构造器初始化（即必须要在对象生成之时有赋值操作）
11.抽象类和抽象方法(abstract关键字)
//1.抽象类是无法实例化的，开发中一般都会提供抽象类的子类，让子类去实例化。
//2.抽象方法，没有方法体，抽象方法所在的类一定是抽象类。
//3.若子类重写了父类的所有的抽象方法，此子类方可实例化；若子类没有重写父类所有的抽象方法，则该子类必须定义为抽象类。
12.interface关键字
//1.接口中能定义全局常量 public static final (可以省略) 和 抽象方法 public abstract(可以省略)
//2.接口中不能定义构造器，意味着不能实例化
//3.如果实现类覆盖了接口所有的抽象方法，则该实现类可以实例化；否则该实现类必须是抽象类
//4.一个类可以实现多个接口。class A extends B implements C,D { }
//5.接口和接口之间可以多继承 interface A extends B,C {}
@Test
public void test() {
Computer com = new Computer();
//Usb usb = new Flash() 接口的使用体现了多态性
com.transfer(new Flash());
}
class Computer {
void transfer(Usb usb) {
usb.start();
usb.stop();
}
}
interface Usb {
void start();
void stop();
}
class Flash implements Usb {
@Override
public void start() {
log.info("Flash---start");
}
@Override
public void stop() {
log.info("Flash---end");
}
}
13.接口和抽象类异同
相同：都不能实例化，一般都含有抽象方法
不同：类：单继承； 接口：多继承 类和接口间：多实现
