前述：利用一段较为充足暑假时间，对以前的Java学习进行一个系统性的回顾，对于部分知识点进行记录和积累。本部分主要记录了Java中各种概念和细节基础，作为笔记，便于理解、学习和记忆。
Java基础笔记
一 局部变量和成员变量：
定义位置不一样【重点】
局部变量：方法的内部
成员变量：在方法的外部，直接写在类当中
作用范围不一样【重点】
局部变量：只有方法当中才可以使用，出了方法就不能再用
成员变量：整个类全都可以通用。
默认值不一样【重点】
局部变量：没有默认值，如果要想使用，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样
内存的位置不一样(了解)
局部变量：位于栈内存
成员变量：位于堆内存
生命周期不一样(了解)
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
注意：
当方法的局部变量和类的成员变量重名的时候，根据"就近原则"，优先使用局部变量。
如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名，通过谁调用的方法，谁就是this。
1 public classDemo01VariableDifference {2
3 String name; //成员变量
4
5 public voidmethodA() {6 int num = 20; //局部变量
7 System.out.println(num);8 System.out.println(name);9 }10
11 public void methodB(int param) { //方法的参数就是局部变量12 //参数在方法调用的时候，必然会被赋值的。
13 System.out.println(param);14
15 int age; //局部变量16 //System.out.println(age);//没赋值不能用17
18 //System.out.println(num);//错误写法！
19 System.out.println(name);20 }21
22 }二 面向对象的三大特征：
封装、继承和多态
封装：封装性就是将一些细节信息隐藏起来，对外界不可见
方法就是一种封装
关键字private也是一种封装
一旦使用了private进行修饰，那么本类当中仍然可以随意访问。但是超出了本类范围之外就不能再直接访问了。
间接访问private成员变量，就是定义一对儿Getter/Setter方法
三 构造方法：
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
注意事项：
构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
构造方法不要写返回值类型，连void都不写
构造方法不能return一个具体的返回值
如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。
一旦编写了至少一个构造方法，那么编译器将不再赠送。
构造方法也是可以进行重载(方法名称相同，参数列表不同)的。
1 public classStudent {2
3 //成员变量
4 privateString name;5 private intage;6
7 //无参数的构造方法
8 publicStudent() {9 }10
11 //全参数的构造方法
12 public Student(String name, intage) {13 this.name =name;14 this.age =age;15 }16 }四 JavaBean：
一个标准的类又称为JavaBean，通常由四部分组成
所有的成员变量都要使用private关键字修饰
为每一个成员变量编写一对儿Getter/Setter方法
编写一个无参数的构造方法
编写一个全参数的构造方法
五 匿名对象：
匿名对象就是只有右边的对象，没有左边的名字和赋值运算符
注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。
使用建议：如果确定有一个对象只需要使用唯一的一次，就可以用匿名对象。
1 //匿名对象
2 new Person().name = "张磊";3
4 //普通使用方式
5 Scanner sc = newScanner(System.in);6 int num =sc.nextInt();7
8 //匿名对象的方式
9 int num = newScanner(System.in).nextInt();10 System.out.println("输入的是：" +num);11
12 //使用一般写法传入参数
13 Scanner sc = newScanner(System.in);14 methodParam(sc);15
16 //使用匿名对象来进行传参
17 methodParam(new Scanner(System.in));六 ArrayList类：
ArrayList中常用的方法
public boolean add(E e)：向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。
备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。但是对于其他集合(今后学习)来说，add添加动作不一定成功。
public E get(int index)：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。
public E remove(int index)：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。
public int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数。
向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”
基本类型
包装类(引用类型，包装类都位于java.lang包下)
byte
Byte
short
Short
int
Integer 【特殊】
long
Long
float
Float
double
Double
char
Character 【特殊】
boolean
Boolean
注意事项：
ArrayList集合的长度可以随意变化，与数组不同
对于ArrayList来说，有一个尖括号代表泛型。
泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。
注意：泛型只能是引用类型，不能是基本类型。
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。如果内容是空，得到的是空的中括号：[]
七 String类：
字符串的特点：
字符串的内容永不可变。【重点】
正是因为字符串不可改变，所以字符串是可以共享使用的。
字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。
创建字符串的常见3+1种方式
三种构造方法：
public String()：创建一个空白字符串，不含有任何内容。
public String(char[] array)：根据字符数组的内容，来创建对应的字符串。
public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。
一种直接创建：
String str = "Hello"; // 右边直接用双引号
1 public classDemo01String {2
3 public static voidmain(String[] args) {4 //使用空参构造
5 String str1 = new String(); //小括号留空，说明字符串什么内容都没有。
6 System.out.println("第1个字符串：" +str1);7
8 //根据字符数组创建字符串
9 char[] charArray = { 'A', 'B', 'C'};10 String str2 = newString(charArray);11 System.out.println("第2个字符串：" +str2);12
13 //根据字节数组创建字符串
14 byte[] byteArray = { 97, 98, 99};15 String str3 = newString(byteArray);16 System.out.println("第3个字符串：" +str3);17
18 //直接创建
19 String str4 = "Hello";20 System.out.println("第4个字符串：" +str4);21 }22
23 }String当中与转换相关的常用方法
public char[] toCharArray()：将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes()：获得当前字符串底层的字节数组。
public String replace(CharSequence oldString, CharSequence newString)：将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
1 public classDemo04StringConvert {2
3 public static voidmain(String[] args) {4 //转换成为字符数组
5 char[] chars = "Hello".toCharArray();6 System.out.println(chars[0]); //H
7 System.out.println(chars.length); //5
8 System.out.println("==============");9
10 //转换成为字节数组
11 byte[] bytes = "abc".getBytes();12 for (int i = 0; i < bytes.length; i++) {13 System.out.println(bytes[i]);14 }15 System.out.println("==============");16
17 //字符串的内容替换
18 String str1 = "How do you do?";19 String str2 = str1.replace("o", "*");20 System.out.println(str1); //How do you do?
21 System.out.println(str2); //H*w d* y*u d*?
22 System.out.println("==============");23
24 }25
26 }八 Static关键字：
Static修饰成员变量与方法
如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据
一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
静态变量：类名称.静态变量
静态方法：类名称.静态方法()
注意事项：
静态不能直接访问非静态。
因为在内存当中是【先】有的静态内容，【后】有的非静态内容。
“先人不知道后人，但是后人知道先人。”
静态方法当中不能用this。
this代表当前对象，通过谁调用的方法，谁就是当前对象。
静态代码块
格式：
1 public class类名称 {2 static{3 //静态代码块的内容
4 }5 }特点：
当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行。
静态代码块的典型用途：用来一次性地对静态成员变量进行赋值。
九 Arrays类：
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作
public static String toString(数组)：将参数数组变成字符串(按照默认格式：[元素1, 元素2, 元素3...])
public static void sort(数组)：按照默认升序(从小到大)对数组的元素进行排序。
备注：
如果是数值，sort默认按照升序从小到大
如果是字符串，sort默认按照字母升序
如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持。
十 继承：
继承的基本概念图
在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待
1 定义父类的格式：(一个普通的类定义)2 public class父类名称 {3 //...
4 }5
6 定义子类的格式：7 public class 子类名称 extends父类名称 {8 //...
9 }在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式
直接通过子类对象访问成员变量：等号左边是谁，就优先用谁，没有则向上找。
间接通过成员方法访问成员变量：该方法属于谁，就优先用谁，没有则向上找。
1 public classDemo01ExtendsField {2
3 public static voidmain(String[] args) {4 Fu fu = new Fu(); //创建父类对象
5 System.out.println(fu.numFu); //只能使用父类的东西，没有任何子类内容
6 System.out.println("===========");7
8 Zi zi = newZi();9
10 System.out.println(zi.numFu); //10
11 System.out.println(zi.numZi); //20
12 System.out.println("===========");13
14 //等号左边是谁，就优先用谁
15 System.out.println(zi.num); //优先子类，20016 //System.out.println(zi.abc);//到处都没有，编译报错！
17 System.out.println("===========");18
19 //这个方法是子类的，优先用子类的，没有再向上找
20 zi.methodZi(); //20021 //这个方法是在父类当中定义的，
22 zi.methodFu(); //100
23 }24
25 }
1 public classFu {2
3 int numFu = 10;4
5 int num = 100;6
7 public voidmethodFu() {8 //使用的是本类当中的，不会向下找子类的
9 System.out.println(num);10 }11
12 }
1 public class Zi extendsFu {2
3 int numZi = 20;4
5 int num = 200;6
7 public voidmethodZi() {8 //因为本类当中有num，所以这里用的是本类的num
9 System.out.println(num);10 }11 }各类变量的访问方式
局部变量： 直接写成员变量名
本类的成员变量： this.成员变量名
父类的成员变量： super.成员变量名
在父子类的继承关系当中，创建子类对象，访问成员方法的规则
创建的对象是谁，就优先用谁，如果没有则向上找。
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的
方法覆盖重写
必须保证父子类之间方法的名称相同，参数列表也相同。
@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示：java.lang.Object类是所有类的公共最高父类(祖宗类)，java.lang.String就是Object的子类。
子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > (default) > private
备注：(default)不是关键字default，而是什么都不写，留空。、
方法的覆盖重写特点：创建的是子类对象，则优先用子类方法
与重载的区别：
重写(Override) ：方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载(Overload)：方法的名称一样，参数列表【不一样】。
方法覆盖重写的应用场景
继承关系中，父子类构造方法的访问特点
子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。
子类构造可以通过super关键字来调用父类重载构造。
super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
总结：子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。
1 public class Zi extendsFu {2
3 publicZi() {4 super(); //在调用父类无参构造方法5 //super(20);//在调用父类重载的构造方法
6 System.out.println("子类构造方法！");7 }8
9 public voidmethod() {10 //super();//错误写法！只有子类构造方法，才能调用父类构造方法。
11 }12
13 }Java继承的三个特点
十一 super&this：
super关键字的用法有三种(用于访问父类的相关内容)
1、在子类的成员方法中，访问父类的成员变量。
