第一天：
过了一下java基础语法：
关键字
标识符
注释 ： // /* */
常量： public static final String ORDER_TYPE;
进制和进制转换： 二进制0b、八进制0、十进制、十六进制0x
变量： String orderNo;int a;
数据类型和类型转换：
8大基本数据类型：byte(1个字节(8位),-128——127)、short(2个字节，65000左右)、int(4个字节,21亿左右)、long(8个字节)、float、double、boolean、char——Byte、Short、Integer、Long、Float、Double、Boolean、Char
运算符: 算术运算符:+ - * / % ++ -- 赋值运算符:= += -= *= /= (a += b;--> a=a+b;) 比较运算符:> < >= <= == != 逻辑运算符:&(and) |(or) ^(异或->如果2个元素不一样，则ture；否则flase) !(非) &&(短路and) ||(短路or)
位运算符: >>1(乘以2) <<2(除以2) >>>(忽略符号位) & | ^ 0001 0010 & 0000
1001 1010 | 1011
1001
1010 ^
0011
三目运算符: ?:: int a=5; int b; a>0?b=1:b=0;
方法 返回值、参数
数组 [] int[] String[]
String[] args = {"a","b","c"};
String[] args2 = new String[5];
'[[],[]] int[][] arr = new int[2][2];
int[][] arr2 = new int[9][9];
数组的长度、下标(最大值位长度-1)
ArrayIndexOutOfBoundsException(数组下标越界)
面向对象的思想：
面向过程思想对比
好处：简单、方便维护
类与对象的关系:
类：一种事物的抽象、有属性和行为
对象：类的一个具体，个体。
对象的内存图：
成员变量与局部变量：
成员变量：定义在类里，方法之外的变量
局部变量：方法里面的变量，参数列表里的变量
区别：位置不同、生命周期不同(成员变量随着对象存在而存在、局部变量方法调用结束就释放掉)、作用域(成员变量整个类都能使用，局部变量只能在该方法内使用)；成员变量有默认赋值，局部变量没有。
方法值的传递：
当传递的是基本数据类型的时候，原值不会改变；
当传递的是非基本类型数据的时候，原值会改变。注意String
封装(private)：
实现方式：
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
隐藏实现细节，提供公共的访问方式 提高了代码的复用性 提高安全性。 封装原则： 将不需要对外提供的内容都隐藏起来。 把属性隐藏，提供公共方法对其访问。
第二天：
匿名对象
new Phone().show("hi");
用在只调用一次;作为参数传递。
构造方法：
没有返回值，方法名和类名一模一样
重载overload：在同一个类里，方法名一样，参数列表不一样
建议：要不就不写，要写一定要写上无参构造器。
成员方法：
不是构造方法的方法
重写override：在父类和子类里面，有一个方法名一样，参数列表一样的方法
重写父类的方法，调用时，用子类新的方法。
-练习：
定义一个FourOperations的类，里面有2个int的属性，定义4个方法， add sub mul div
然后写一个Test类，在类里创建一个对象，设置2个属性，调用4个方法。
static：
静态的，可以标识方法、内部类、变量；
静态方法通过类名.方法名 来调用 只能使用静态成员变量
静态的方法、变量、类都在静态区。
静态变量
静态变量随着程序的加载而赋初值，不依赖对象。
main方法的讲解
public static void main(String[] args){``}
public 权限 static 不依赖对象运行 void 不需要返回值 main 约定方法名 String[] args 运行时参数
工具类：
全都是静态方法的类，实现了很多小功能
StringUtils,MathUtil
javadoc：
/**
*@author zsj
*@data 2021-01-12
*/
/**
*返回字符串是否为空
*
*@param str 需要判断的字符串
*@return 空返回 true 非空返回false
/*
生成：javadoc xxx.java
猜数字小游戏
代码块 -猜结果
继承:
好处：
方便维护、代码复用
弊端：
加重代码的耦合度（代码间的依赖）
-成员变量：
private成员变量不能继承，其他都可以
-this和super：
this:当前对象
super:new子类的同时创建的父类对象
-构造方法：
构造方法是不能继承，
但是子类可以通过super来访问
-方法重写：
set方法的重写不好实现
就近原则，从子类一直往上找，找到了就用
-猫狗案例
final：
最终的，不让改的。标识类，那么这个类不能被继承；标识变量，变量不能被修改(需要注意非基本数据类型)
多态:
子类对象可以直接用父类接收(Human human = new Chinese("中文");)(向上转型)
父类对象经过判定后可以转换为子类对象
(if (human instanceof Chinese) c = (Chinese) human;)(向下转型)
好处：
定义方法的时候，使用父类；传递参数可以传递多个子类。一次定义，多处调用。
抽象类：
具有抽象方法的类，就叫抽象类。
继承了抽象类的非抽象类必须实现抽象方法。
(public abstract class AbstractCat extends AbstractAnimal)
接口:
一系列方法的标准化。
规范代码。
多态的使用，方便使用。
小案例
猫狗案例：
Animal 类：name,age
IAnimal 接口： eat,sleep
Cat类 继承Animal实现IAnimal
Dog类 继承Animal实现IAnimal
package:
包、文件夹
一把情况下，package都在第一行
import：
导入
一般在package下面，class上面
权限修饰符:
public： 所以地方
protected： 本类、同一个包里的类、子类
default(不写)：本类和同一个包里的类
private：本类
内部类：
定义在类中的类。分为成员内部类，和局部内部类；
成员内部类使用 new Outer().new Inner();的方式new出来
局部内部类使用局部变量，在jdk8以前 需要注意，局部变量需要加final声明
匿名内部类
没有名字的局部内部类，一般是某个类的子类，重写了某个或者某些方法。
jFrame.addWindowListener(new WindowAdapter(){
@Override
public void windowClosed(WindowEvent e){
super.windowClosed(e);
}
});
标准类：
package com.lesson3;
/**
*一个手机类
*
*@author zsj
*/
public class Phone{
/**
*品牌
*/
private String brand;
/**
*价格
*/
private String price;
/**
*颜色
*/
private String color;
/**
*尺寸
*/
private String size;
public Phone(){
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getPrice() {
return price;
}
public void setPrice(String price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getSize() {
return size;
}
public void setSize(String size) {
this.size = size;
}
@Override
public String toString() {
return "Phone{" +
"brand='" + brand + '\'' +
", price='" + price + '\'' +
", color='" + color + '\'' +
", size='" + size + '\'' +
'}';
}
}
