常用的集合

ArrayList集合

类ArrayList //E表示泛型
泛型，就是装在集合当中的所有元素，全都是统一的什么类型

注意：泛型只能是引用类型，不是基本类型

注意事项，对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
如果内容是空的，得到的是空的中括号[]。
数据必须和泛型的数据类型一致。

格式：

ArrayList<String> list = new ArrayList<>();
//添加数据
list.add("dsfs");
//获取数据
list.get(索引值);
//删除数据
list.remove(索引值);

ArrayList当中的常用方法

1. public boolean add(E e)
   向集合当中添加元素，参数的类型和泛型一致，返回值代表添加是否成功。
   备注：对于ArrayList集合来说，add添加动作是一定成功的，所以返回值可用可不用。
   但是对于其他集合（后边学习），add不一定添加成功。

2. public E get(int index)
   从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。

3. public E remove(int index)
   从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。

4. public int size()
   获取集合的大小长度，返回值是集合中包含的元素个数。

包装类

如果希望向ArrayList当中存储基本类型数据，必须使用基本数据类型对应的包装类
基本类型 包装类（引用类型，包装类都位于java.lang包下）
int Integer
char Character
只需记住两个特殊的，其余都是首字母大写。

从JDK 1.5+开始，支持自动开箱、装箱
自动装箱：基本数据类型–>包装类型
自动拆箱反过来

字符串

java.lang.String类代表字符串。
API当中说，Java程序中的所有字符串字面值（如：abc）都作为此类的实例实现。
也就是说，程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是）

String字符串的特点：

1. 字符串的内容用不可变。【重点】
2. 正是因其不可变性，字符串可以共享使用
3. 字符串效果上相当于char[]字符数组，但是底层原理是byte[]字节数组

创建字符串的常见3+1种方式：

三种构造方法：

1. public String():穿件一个空白字符串，不含任何内容。
2. public String(char[] array):根据字符数组的内容，来创建对应的字符串
3. public String (byte[] array):根据字节数组的内容，来创建对应的字符串
   一种直接创建：
   String str = “Hello”;

代码：

//使用空参构造
String str1 = new String(); //小括号留空，说明字符串什么内容都没有。System. out . println("第1个字符串:”+ str1);
//根据字符数组创建字符串
char[] charArray = { 'A', 'B', 'C' };
String str2 = new String(charArray);
System. out . println("第2个字符串:” str2);
//根据字节数组创建字符串
byte[] byteArray = { 97, 98， 99 };
String str3 = new String(byteArray);
System. out. println("第3个字符串:”+ str3);
//直接创建
String str4 = "Hello";
System. out . println("第4个字符串:”+ str4);

字符串如何共享使用

字符串的常量池：程序当中直接写上双引号字符串，就在字符串的常量池当中
堆内存当中的字符串常量池中的字符串对象，保存的是byte数组的地址值
创建一个char类型数组，在堆中分配了地址空间，使用构造方法String(char[] array)创建（new）一个String对象，该对象是属于堆中新开辟出来的空间，而之前堆中char[]类型的数组，会自动转化成byte类型数组。

1. 对于引用类型来说，==进行的是地址值的比较。
2. 双引号直接写的字符在常量池当中，new的不在池当中。

字符串比较的相关方法

== 是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：
public boolean equals(Object obj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的彩绘会给true；否则返回false。

注意：

String str5 = nu11;
System. out . println("abc" . equals(str5)); //推荐: false
System . out. println(str5.equals("abc")); //不推荐:报错，空指针异常NullPointerException

注意事项：

1. 任何对象都能用Object进行接收。
2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)是一样的。
3. 如果比较双方一个常量一个变量，推荐吧常量字符串写在前面。
   推荐：“abc” . equals(str5)

public boolean equalsIgnoreCase(String str): 忽略大小写，进行内容比较。

String当中与获取相关的常用方法有：

获取长度：
public int Length():获取字符串当中含有的字符个数，拿到字符串长度。
拼接成新的字符串：
public String concat(String str):将当前字符串和参数字符串拼接成为返回值新的字符串
获取索引位置的字符：
public char chartAt(int index):获取制定索引位置的单个字符。（索引从0开始）
查找索引位置：
public int indexof(String str):查找参数字符串在本字符串当中首次出现的索引位置，如果没有，则返回-1值。（只看第一次）

字符串的截取方法：
public String substring(int index):截取从参数位置一直到字符串末尾，返回新的字符串。
public String substring(int begin,int end):截取从begin开始，直到end结束，中间的字符串。

//下面这种写法，字符串的内容仍然是没有改变的
//下面有两个字符串: “Hello”, “Java”
String strA = “He11o”;
System.out.println(strA); // Hello
strA = “Java”;
System.out.println(strA); // Java
//strA当中保存的是地址值。
//本来地址值是Hello的0x666,
//后来地址值变成了Java的0x999
//改变的都是地址值，字符串的内容仍然不可改。

/每当感觉字符串的值改变，必然是创建了新的字符串/

String当中与转换相关的常用方法有：
public char[] toCharArray():将当前字符串拆分成字符数组作返回值。
public byte[] getBytes():获取当前字符串底层的字节数组。
public String replace(CharSequence oldString,charSequence newString)：将所有出现的老字符串替换成为新的字符串，返回之后的结果新字符串。

字符串的分割方法：

public String[] split(String regex):按照参数的规则，将字符串切成若干部分。

注意事项：

split方法的参数其实是一个正则表达式，目前要注意，如果按照英文句点“.”进行切分，必须写"\."(两个反斜杠)

静态关键字static概述

一旦成员变量使用了static关键字，那么这样的内容就不再属于对象自己，而是属于类，所以凡是类的对象（多个）都共享同一份。
例子：
学生类的成员变量：
private String name; //姓名
private int age; //年龄
static String room; //所在教室

测试代码：

Student one = new Student(name: "郭靖"，age: 19);
one.npom = “101教室" ;
System.out.println("姓名: " + one.getName() + ",年龄:”+ one.getAge() + ",教室:”+ one.room);
Student two = new Student( name:“黄蓉"，age: 16);
System.out.println("姓名:" + two. getName() + ",年龄:”+ two.getAge() + ",教室:”+ two.room);

运行结果：
姓名:郭靖，年龄: 19,教室: 101教室
姓名:黄蓉，年龄: 16,教室: 101教室

使用static关键字还可以给学生添加自增学号：
1、定义一个学生变量
2、定义成员变量

一旦使用static修饰成员方法，那么这就成为了静态方法，静态方法不属于对象，而是属于类。如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。

对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用，建议通过类名称直接调用。
否则会误以为是普通成员方法。

无论是成员变量还是成员方法，如果有了static关键字修饰，都推荐使用类名称直接访问：
静态变量：类名称.静态变量
静态方法：类名称.静态方法()

对于本类当中的静态方法，调用时可以省略类名称。

注意事项：

1、静态不能直接访问非静态。【重点】
原因：因为在内存中是先有的静态内容，后有的非静态内容。
2、静态方法中不能使用this。
原因：静态方法调用时不需要使用对象名，而this就代表当前对象，相互矛盾。

注意：使用类名称访问静态成员变量的时候，全程就和对象没关系，只和类有关系。

静态代码块的格式是：
public class 类名称{
Static{
//静态方法块内容
}
}
特点：当本类第一次使用时，静态代码块执行唯一的一次。
静态内容总是优先于非静态内容，所以静态代码块比构造方法先执行。

静态代码块的典型用途，用来一次性的对静态成员变量进行赋值。

数组工具类Arrays

java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组的常见操作。
public static String toString(Array):将参数数组变成字符串。（按照默认格式：[元素1，元素2，元素3，…]

public static void sort(Array):将参数数组元素按照升序排列。

备注：
1、如果是数值，sort默认按照升序从小到大。
2、如果是字符串，sort默认按照首字母升序。
3、如果是自定义类，则需要有comparable或者comparator接口的支持。（以后学习）

数学工具类Math

java.util.Math是一个与数学相关的工具类，里面提供了大量静态方法，完成与数学运算相关的操作。
public static double obs(double num):获取绝对值。
public static double ceil(double num):向上取整。
public static double floor(double num):向下取整。
public static long round(double num):四舍五入，不带小数点。

Math.PI代表圆周率

继承

面向对象三大特征：封装性、继承性、多态性。
继承是多态的前提，如果没有继承，就没有多态。

继承主要解决的问题就是：共性抽取。
父类，也可称为基类，或超类
子类，也可以叫做派生类

在继承的关系中，子类可以被当做父类看待。

父类就是一个普通的类

子类定义的格式：
public class 子类名称 extends 父类名称{
//…
}

在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
1、直接通过子类对象访问成员变量，等号左边是谁，就优先用谁，没有则向上找。
//Zi zi = new Zi（），优先用zi
2、间接通过成员方法访问成员变量，方法属于谁，就优先用谁，没有就向上找。

局部变量 直接写成员变量名
本类的成员变量 this.成员变量名
父类的成员变量 super.成员变量名

3、在父子类的继承关系中，创建子类对象，访问成员方法的规则：创建对象是谁，就优先用谁，如果没有就向上找

注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类。

重载和重写

重写（override）
概念：在继承关系中，方法的名称一样，参数列表也一样。
也叫做方法的覆盖，覆写。

重载（overload）——方法名称一样，参数列表不一样。

方法覆盖重写的注意事项：

1、必须保证父子类之间方法的名称相同，参数列表也相同。
@override，写在方法前面，用来检测是不是有效的正确覆盖重写。
这个注解就算不写，只要满足要求，也是正确的覆盖重写。
2、子类方法的返回值必须【小于等于】父类方法的返回值范围。
前提：java.lang.Object类时所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。
3、子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > (default) > private
备注：（default）不是关键字default，而是什么都不写，留空。

设计原则：
对于已经投入使用的类，尽量不要进行修改。
推荐定义一个新的类，来重复利用其中的共性内容，并且添加改动新内容。

继承关系中，父子类构造方法的访问特点

1、子类构造方法中有一个默认隐含的“super()”调用，所以一定是先调用父类构造，后执行的子类构造。
2、子类构造可以用super关键字调用父类重载构造。
3、super的父类构造调用，必须是子类构造方法的第一个语句，不能是一个子类构造调用多次super构造。
总结：
子类必须调用父类构造方法，不写则赠送super()，写了则用写了的指定super调用，super只能有一个且必须是第一个。

super关键字的用法有三种：

1、在子类的成员方法中，访问父类的成员变量。
2、在子类的成员方法中，访问父类的成员方法。
3、在子类的构造方法中，访问父类的构造方法。

Super关键字用来访问父类内容，this关键字用来访问本类内容。用法也有三种：
1、在本类成员方法中，访问本类的成员变量。
2、在本类成员方法中，访问本类的另一个成员方法。
3、在本类的构造方法中，访问本类的另一个构造方法。
在第三种用法中要注意：
A. this(…)调用也必须是构造方法的第一个语句，唯一一个。
B. super和this两种构造，不能同时调用。

Java是单继承语言，一个类只能有一个父类。

Java语言可以多级继承。
A extends B
B extends C

java.lang.Object是最高一级，

一个子类的直接父类是唯一的，但是一个父类可以有多个子类。
A extends C
B extends c

抽象的概念

如果父类当中的方法不确定如何进行{}方法体的实现，那么这就应该是一个抽象方法。

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类才行，在class之前写上abstract即可。

如何使用抽象类和抽象方法：

1、不能直接创建抽象类对象。
2、必须创建一个子类来继承抽象父类。
3、这个子类必须覆盖重写抽象类当中的所有抽象方法。
覆盖重写（实现），子类去掉抽象方法的abstract关键字，然后补上方法体即可
4、创建子类对象进行使用。

注意事项：

1、抽象类不能创建对象，只能创建其抽象子类的对象。
2、抽象类中，可以有构造方法，是供子类对象创建时，初始化父类成员使用的。
3、抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
一个抽象类不一定有抽象方法，只要保证抽象方法所在的所在的类时抽象类即可，这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊的场景下有用涂。比如，设计模式中的适配器模式（没有任何抽象方法的抽象类）。
4、抽象类的子类，必须重写抽象父类中的所有抽象方法，否则，编译无法通过而报错，除非该子类也是抽象类。

练习题：发红包案例。
用户类，群主和普通成员，共性抽取，成员变量——姓名、余额。
群主类和普通成员类继承用户类。

分析：
发红包的逻辑，三要素：
返回值：ArrayList
方法名称：send
参数列表：1、总共发多少。int totalMoney
2、分成多少份。int count
public ArrayList send(int totalMoney, int count){
//…
}

收红包的逻辑，三要素：
返回值类型：void
方法名称： receive
参数列表： ArrayList array
public void receive(ArrayList) {
//…
}

实现：练习红包案例。