好长时间了，之前记的。用的着收好。
1.前++后++
自增运算符：++
自减运算符：--
基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式：写在变量名称之前，或者写在变量名称之后。例如：++num，也可以num++
使用方式：
1. 单独使用：不和其他任何操作混合，自己独立成为一个步骤。
2. 混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合，等。
使用区别：
1. 在单独使用的时候，前++和后++没有任何区别。也就是：++num;和num++;是完全一样的。
2. 在混合的时候，有【重大区别】
A. 如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。 【先加后用】
B. 如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】。 【先用后加】
例如：// 与打印操作混合的时候
int num2 = 20;
// 混合使用，先++，变量立刻马上变成21，然后打印结果21
System.out.println(++num2); // 21
System.out.println(num2); // 21
System.out.println("=================");
int num3 = 30;
// 混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31
System.out.println(num3++); // 30
System.out.println(num3); // 31
System.out.println("=================");
2.封g、s
封装中get、set方法中：
set是有参无返回值，并且是往里放。
get是无参有返回值，并且是往外拿。
3.Scanner、Random、ArrayList小杂
Scanner类是属于控制台输出，有普通的，和匿名的两种。
Random用来生成随机数字，其方法和Scanner方法一样，只是不带参数，还有在使用nextInt()是范围是正负21亿。
当nextInt(n)中有参数时就是代表随机数是一个左闭右开区间的范围（【0~n)范围也就是0~n-1）
ArrayList list = new ArrayList<>();ArrayList集合，但凡在jdk1.7以上的版本后面的ArrayList<>都不用写参数，否则反之。
list.add( );这是增加索引，
list.get()从元素中获取
list.remove()从元素中删除元素
list.size()获取元素的长度
4.基本数据类型小杂
八个基本类中一般都是把首字母变成大写就变成包装类了，而int和char的包装类是特殊的，
int的包装类是Integer,char的包装类是Character.
5.字符串大杂
String 字符串中==是地址相等
例如： public static void main(String[] args) {
String str1 = "abc";
String str2 = "abc";
char[] charArray = {'a','b','c'};
String str3 = new String(charArray);
System.out.println(str1 == str2);//ture
System.out.println(str1 == str3);//false
System.out.println(str2 == str3);//false
}
如果字符串是equals的话比较的是内容
例如： System.out.println(str1.equals(str2));//ture
System.out.println(str1.equals(str3));//ture
System.out.println(str2.equals(str3));//ture
但比较大小写的话就会是flase,其中如果是equalsIgnoreCase()就是ture,Ignore是忽略，Case大小写。
并且只有英文字母区分大小写，中文没有，会出现false.
例如：
String strA = "Java";
String strB = "java";
System.out.println(strA.equals(strB));//严格区分大小写 false
System.out.println(strA.equalsIgnoreCase(strB));// ture
String 当中与获取相关的常用方法
public int length()获取字符串中字符的个数
例如：
int ch = "jfijfjfjfllf".length();
System.out.println("字符串的长度是："+ch);//出来长度12
public String concat( String str);将当前字符串和参数字符串拼接成返回值的字符串。
例如：
String str1 = "Hello";
String str2 = "World";
String str3 = str1.concat(str2);
System.out.println(str1);//Hello
System.out.println(str2);//World
System.out.println(str3);//HelloWorld
public char charAt(int indenx):查取指定索引位置的单个字符
例如：
char hh = "Hello".charAt(1);
System.out.println("在字符串中第一个索引是："+hh);//会把字符串中被索引的字母搜出来的，这个查询和
//数组的查询方式一样按0.1.3.....de 方式
public int indexof(String str):查找参申诉字符串在本字符串当中首次出现的索引位置，如果没有返回-1值
例如：
String str6 = "HelloWorld";
int h = str6.indexOf("llo");
System.out.println("第一次索引值是："+h);//查找参数字符串在本来字符串中的第一索引位置
int asd = str6.indexOf("asd");
System.out.println("第一次索引值是："+asd);//如果根本没有，返回-1值。
public String substring(int index):截取从参数位置一直到字符末尾，返回新字符串。
public String substring(int begin,int end):截取从begin开始end结束，中间的字符串。备注：【begin,end),包含左边，不包含右边。
例如：
public static void main(String[] args) {
String str1 = "HelloWorld";
String sub = str1.substring(5);
System.out.println(str1);
System.out.println(sub);//World
String sub2 = str1.substring(4, 7);
System.out.println(sub2);//owo
}
public char[ ] toCharArray():将当前字符串拆分成为字符数组作为返回值
public byte[ ] getBytes():获取当前字符串底层的字节数组。
public String replace( CharSequrnce oldString,CharSequence newString):
将所有出现的老字符串替换成为新字符串，返回替换之后的结果新字符串。
例如：
char[] ch = "Hello".toCharArray();
System.out.println(ch[0]);
System.out.println(ch.length);//5
byte[] k = "ABC".getBytes();
for (int i = 0; i < k.length; i++) {
System.out.println(k[i]);//65.66.67
}
String str2 = "How do you do?";
String he = str2.replace("o", "*");
System.out.println(str2);//How do you do?
System.out.println(he);//H*w d* y*u d*?
String str3 = "雷吱木吱嘎，丢类老母";
String ma = str3.replace("丢类老母", "****");
System.out.println(ma);//雷吱木吱嘎，****
分割字符串的方法;
public String[] split(String regex):按照参数的规则，将字符串切分成为若干部分。
注意事项：split方法的参数其实是一个“正则表达式”，今后学习。
今天要注意：如果要按照英文句点"."进行切分，必须写“\\.(两个反斜杠)”
6.静态变量小杂
static静态关键字，在类中使用可属于每个对象，调用。
光标放在需要修改的变量名上，然后shift + F6~ 完美~
static静态方法不用创建对象可以直接调用，调用时一半建议用类名.方法名
无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
静态变量：类名称.静态变量
静态方法：类名称.静态方法（） 注意：静态方法中不能出现this对象
注意：静态不能访问非静态。原因：因为在内存当中是【先】有静态内容，【后】有的
非静态内容“古人不知今人，但今人知道古人”
static静态代码块，特点：当第一次用到本类时，静态代码执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行。
（1）：静态代码块的典型用途：
用来一次性地对静态变量进行赋值。
private int id()
private static int idCounter = 0;//学号计时器，每当new了一个新对象的时候，计数器++
public static String toString （数组）：将参数组变成字符串，（按照默认格式：[元素1，元素2，元素3.......]）
（2）public static void sort(数组)：按照默认升序（从小到大）对数组元素进行排序。
例如：
int[] str = {1,2,3};
String s = Arrays.toString(str);
System.out.println(s);//[1,2,3]
int[] two = {3,2,4,5,1,9,8};
Arrays.sort(two);
System.out.println(Arrays.toString(two));//[1,2,3,4,5,8,9]
（3）java.util.math类是数学相关的工具类，里面提供大量的静态方法，完成与数学运算符相关的方法
public static double abs( double num):获取绝对值。
public static double ceil( double num):向上取整。
public static double floor( double num):向下取整。
public static long round(double num):四舍五入。
例如：System.out.println(Math.abs(3.14));//3.14
System.out.println(Math.abs(-5.6));//5.6
System.out.println(Math.ceil(3.9));//4.0
System.out.println(Math.ceil(3.1));//4.0
System.out.println(Math.ceil(-3.1));//-3.0
System.out.println(Math.floor(3.9));//3.0
System.out.println(Math.floor(3.1));//3.0
System.out.println(Math.floor(-3.1));//-4.0
System.out.println(Math.floor(-3.1));//-4.0
System.out.println(Math.round(3.5));//4
System.out.println(Math.round(3.1));//3
System.out.println(Math.PI);//3.141592653589793
7.面向对象的三大特性：封装性、继承性、多态性。
继承是多态的前提，如果没有继承就没有多态。
在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。
例如：父类是员工，子类是讲师，那么“讲师就是一个员工”。
在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
直接通过子类对象访问成员变量：
等号左边是谁，就优先用谁，没有则想上找。
简介通过成员方法访问成员变量：
该方法属于谁，就优先用谁，没有则向上找。
在父子关系中，创建子类对象，访问成员方法的规则：
创建的对象是谁，就优先用谁，如果没有则向上找。
例如：
public static void main(String[] args) {
zi h = new zi();
h.methodzi();//子类构造方法。
h.methodfu();//父类构造方法。
h.method(); //子类构造方法。22
}
重写（Override）
概念：在继承关系中，方法和名称一样，参数列表也一样。
重写（Override):方法的名称一样，参数列表【也一样】。最好叫覆盖、覆写
重载（Overload):方法名称一样，参数列表【不一样】。
方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。
方法覆盖重写的注意事项：
1.必须保证父子类之间方法的名称相同，参数列表也相同。
@Overriad:写在方法前面，用来检测是不是有效的正确覆盖重写。
这个注解就算了，只要满足要求，也是正确的方法覆盖重写。
2.子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示：java.lang.object类是所有类的公共最高类（祖宗类），java.lang.String
就是object的子类。
3.子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public>protected>(default)>private
备注：（default）不是关键字ddefault,而是什么都不写，留空。
其中有一个super的用法，//把父类的show方法拿过来重复利用//自己子类在添加更多内容。
==============================
this和super两种构造调用，不能同时使用，还有它们都是也必须是构造方法的第一个语句，
唯一一个。在同一个调用中不会有第二个this和super。
=============================================
如何使用抽象类抽象方法：
1.不能直接创建new对象。
2.必须用一个子类来继承抽像父类。
接口：接口是一种公共的规范标准
接口中：抽象是abstract,默认是default,静态方法是static.
静态跟对象没关系，跟类有关系。
而且静态方法中：不能通过接口实现类的对象来调用接口当中的静态方法。
正确用法：通过接口名称，直接调用其中的静态方法。
格式:接口名称.静态方法名（参数）
接口也可以定义“成员变量”，但是必须使用public static final三个关键字
进行修饰。从效果上看，就是接口的常量。
格式：
public static final 数据类型 常量名称 = 数据值；
注意事项：
1.接口当中的常量，可以省略public static final ，注意：不写也一样。
2.接口当中的常量，必须进行赋值；不能不赋。
final 这是一个常量，一旦赋值，不可以修改。
多态：一个对象拥有多种形态，也就是：对象的多态性。
父类引用指向子类对象。
对象的向上转型就是：父类引用指向子类对象。
向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端：
对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。
ClassCastException类转换异常
8.数据结构
栈-----------这个结构就是先进后出。入口和出口在同一侧。
队列---------这个结构就是先进先出。入口和出口在两侧。
数组---------这个结构查询快，增删慢。
查询快：数组的地址是连续的，我们通过数组的首地址可以找到数组，通过数组的索引可以快速查找某一个元素
增删慢：数组的长度是固定的，我们想要增加/删除一个元素必须创建一个新数组，把源数组的数据复制过来
在堆内中，频繁的创建数组，复制数组中的元素，销毁数组，效率低下。
链表----------这个结构查询慢，增删快。
查询慢：链表中地址不是连续的，每次查询元素都必须从头开始查询。
增删快：链表结构，增加/删除一个元素，对链表的整体结构没有影响所以增删快。
链表分两种一种是单向链表，一种是双向链表。
单向链表：链表中只一条子链，不能保证元素的顺序（存储元素和取出元素的顺序有可能一致）
双向链表：链表中有两条链子，有一条链子是专门记录元素的顺序，是一个有序的集合。
