java基础知识-小记

java基础-复习随笔小记

重载

方法重载
1.指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返
回值类型无关。
2.参数列表：个数不同，数据类型不同，顺序不同。
3.重载方法调用：JVM通过方法的参数列表，调用不同的方法。

内存

变量的内存分布

举例：对象内存图
如下：一个对象，调用一个方法内存图

如下是：两个对象调用同一方法内存图

如下图：一个引用，作为参数传递到方法中内存图
对于数组而言

Scanner类、Random类

System.in 系统输入，指的是通过键盘录入数据
Scanner类是一个可以解析基本类型和字符串的简单文本扫描器

Scanner sc = new Scanner(System.in);
int i = sc.nextInt();//接收一个键盘录入的整数

Random类：生成随机数
public int nextInt(n):生成一个0（包括）到n（不包括）之间的值

Random r = new Random();
int i = r.nextInt(10);

ArrayList

ArrayList不能存储基本数据类型，只能存储引用数据类型。所以类似不能写。但是存储基本类型对应的包装类型是可以的。所以要想存储基本数据类型，需要先将数据类型转换为对应的包装类型才可以。转换图如下：

static关键字

static关键字是用来修饰成员变量和成员方法，被修饰的成员是属于类的，而不是单单属于某个对象的。既然说是属于类的，所以不需要创建对象来调用。

static修饰的内容，是随着类的加载而加载的，且只加载一次；
存储于一块固定的内存区域（静态区），所以，可以直接被类名调用；
它优先于对象存在，所以可以被所有对象所共享。

如下是静态static修饰过的内容的内存原理图解：

静态代码块

定义在成员位置，使用static修饰的代码块

位置：类中方法外
执行：随着类的加载执行且执行一次，优先于main方法和构造方法的执行
作用：给类变量进行初始化赋值

public class Student{public static String name;public static ArrayList<String> list;static{//给类变量赋值name = "小可爱";//添加元素到list中list.add("小仙女");}
}

小贴士：
static关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是在不创建对象的情况下，去调用方法。
静态方法可以通过实例化对象后，对象调用的方式完成非静态成员调用。

程序执行顺序

1.无论实例产生多少对象，静态代码块只执行1次
2.构造代码块随实例化过程调用
3.普通代码块随方法调用而执行

方法重写

子类出现了和父类一模一样的方法（返回值类型、参数类型、方法名）时，会出现覆盖效果。也称为重写或复写。声明不变，重新实现。

子类覆盖父类方法，必须保证权限大于等于父类。

继承后的特点–构造方法

1.构造方法的名字和类名是相同的，所以子类是无法继承父类构造方法的；
2.构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中，默认有一个super()，表示调用父类的构造方法，父类成员初始化后，才可以给子类使用。

super和this

父类空间优先于子类对象产生

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于其子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。
理解图如下：
super：代表父类的存储空间标识。（可以理解为对父类的调用）
this：代表当前对象的引用（谁调用就代表谁）

抽象类

继承抽象类的子类必须重写父类的所有方法。否则，该类也要声明为抽象类。最终，必须有子类实现父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

注意事项：
关于抽象类的调用，以下为语法上要注意的细节。虽然条目较多，但若理解抽象类的本质，无需死记硬背。

.抽象类无法创建对象，若创建，则编译无法通过而报错。只能创建其非抽象子类的对象。
理解：假设创建抽象类的对象，则对象调用抽象方法，而抽象方法没有具体的方法体，无意义。
抽象类中，可以有构造方法，是提供子类创建对象时，初始化父类对象使用的。
理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
抽象类中，不一定包含抽象方法；但有抽象方法的类一定是抽象类。
理解：未包含抽象方法的抽象类，目的就是不想让调用者调用该对象，通常用于某些特定的类结构设计。
抽象类的子类，必须重写父类的所有抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
理解：假设不重写所有的抽象方法，则类中可能有抽象方法。在创建对象后，调用抽象的方法，没有意义。

继承的综合案例

综合案例：群主发普通红包。某群有多名成员，群主给成员发普通红包。普通红包的规则：
1.群主的一笔金额，从群主的余额中扣除，平均分成n等分，让群成员领取；
2.成员领取红包后，保存到成员余额中。
请根据描述，完成案例中所有类的定义以及指定类之间的继承关系，并完成发红包的操作。
案例分析：
根据描述，得到如下继承体系：

Collection集合的遍历

Collection接口提供了统一的遍历集合的方式：迭代器模式。通过iterator()方法可以获取一个用户遍历当前集合元素的迭代器（iterator接口）。
java.util.iterator接口：定义了迭代器遍历集合的相关操作，不同的集合都实现了用于遍历自身元素的迭代器实现类，但是我们无需记住它们的名字，从多态的角度把它们看成iterator即可。
迭代器遍历遵循的步骤为：问（hasNext()）、取（next()）、删，但删不是必须操作

public class IteratorDemo{public static void main(String[] args){Collection c = new ArrayList();c.add("one");c.add("#");c.add("two");c.add("#");c.add("three");c.add("#");c.add("four");c.add("#");c.add("five");System.out.println(c);//[one,#,two,#,three,#,four,#,five]/**迭代器的常用方法：1）boolean hasNext()--------------问询问集合中是否还有“下一个”元素可共迭代注意：迭代器默认开始位置在第一个元素之前无论调用多少次hasNext()方法，迭代器的位置都不会改变2）Object next()---------取迭代器向后移动一个位置来指向集合的下一个元素并将其获取**/Iterator it = c.iterator();//获取集合c的迭代器while(it.hasNext()){//若有下一个元素//Object str = it.next();String str = (String)it.next();//获取下一个元素System.out.println(str);if("#".equals(str)){//c.remove(str);//会报错。迭代器在遍历的过程中，无法通过集合的方法增删元素it.remove(str);//删除next()方法所获取的元素}} System.out.println(c);  //把#删掉啦。[one,two,three,four,five]}
}

增强for循环/新循环

集合遍历：iterator
数组遍历：for循环

可使用相同的语法来遍历集合和数组

增强for循环/新循环语法为：

for(元素类型变量名：集合或数组）{ 循环体 }

举例如下：

for(Object num : list){//循环体
}

新循环遍历集合----会被自动转换成迭代器或者for‘循环数组遍历’

Collection相关方法

size():计算长度
add(Object e):添加
remove():删除给定元素
isEmpty():判断是否是空
clear():清空
contains（Object o）判断当前集合中是否包含元素o，包含返回true。
containsAll():判断一个集合中是否包含另一个集合的所有内容
removeAll():删交集
retainAll():取交集
addAll():将一个集合添加到另一个集合中
iterator():获取当前集合对应的迭代器
toArray():将当前集合转换为数组

泛型

泛型也叫参数化类型，允许我们在使用类的时候，传入确切的某类型来规定其内部的属性、方法参数或返回值类型，使得我们使用时更方便。
泛型在集合中被广泛使用，用来指定元素的类型。
若不指定泛型的具体类型，则默认为Object
若不指定泛型的具体类型，则在获取泛型的值时，编译器会补充强转操作

Collection<String> cc = new ArrayList<>();
cc.add("卡哇伊");

List接口

继承自Collection接口，List集合是可重复集合，有序，并且提供了一套可以通过下标操作元素的方法。

常见的实现类有两组：

java.util.ArrayList：内部使用数组实现，查询快（因为有下标,所以更适合查找和更新数组），但增删性能不好（删就要所有元素往前挪，增需要后面所有元素往后挪），只是在链表首部和尾部插入或删除非常有效。
java.util.LinkedList：内部使用链表实现，查询慢，（首、尾的）增删性能稍微好些、适合快速的插入和删除元素

注意：在对集合操作的增删性能没有特别苛刻的要求时，通常选择ArrayList

LinkedList

LinkedList实现List和Queue两个接口

构造方法:

LinkedList() //构造一个空链表
LinkedList(Collection<? extends E> c)//构造一个包含指定Collection中的元素的列表，这些元素按其Collection的迭代器返回的顺序排列

常用方法

boolean add(E e) //添加元素
void add(int index,E e)
boolean addAll(Collection<? extends E> c)//添加指定Collection的所有元素到此列表的结尾
boolean addAll(int index, Collection<? extends E> c)
//添加指定Collection的所有元素从此列表的index位置开始插入
void addFirst(E e)
void addLast(E e)
void clear()
boolean contains(Object o)
E get(int index)
E getFirst()
E getLast()
int indexOf(Object o)   //返回首次出现指定元素的索引，如不包含则返回-1
int lastIndexOf(Object o)   //返回最后一次出现指定元素的索引
E peek() //获取但不移除此列表的头，如列表为空则返回null
E peekFirst()
E peekLast()
E poll()    //获取并移除此列表的头
E pollFirst()
E pollLast()
E pop() //从此列表所表示的堆栈中弹出一个元素
void push(E e)  //将元素推入此列表所表示的堆栈
E remove()  //获取并移除此列表的头（第一个元素）
E remove(int index)     //移除此列表中指定位置的元素
boolean remove(Object e)    //从此列表中删除首次出现的指定元素
E removeFirst() //移除并返回此列表的第一个元素
E set(int index, E e)   //将此列表中指定位置的元素替换为指定元素
int size()      //返回此列表的元素数
Object[] toArray()  //适当以返回元素（从第一个元素返回最后一个元素）包含此数组中所有元素的数组

集合和数组的转换

集合转换为数组：Collection 的 toArray()

public class CollectionToArrayDemo {}

数组转换为集合: Arrays 的静态方法 asList()

public class ArrayToCollectionDemo {}

接口

接口是java语言中的一种引用数据类型，是方法的集合。如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要封装了方法，包括抽象方法（JDK7及以前）、默认方法和静态方法（JDK8）、私有方法（JDK9）。
接口的定义，它与定义类相似，但是它用interface关键字。它也会被编译成.class文件，但一定要明确它不是类，而是另外一种引用数据类型。

引用数据类型：数组、类、接口

//定义格式
public interface InterfaceName{//抽象方法public abstract void method();//默认方法public default void method1(){//执行语句}//静态方法public static void method2(){//执行语句}//私有方法private void method3(){//执行语句}
}

/**基本的实现
类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，或者说接口的子类。
实现的动作类似继承，格式相仿，只是关键字是implements.
非抽象子类实现接口：
1.必须重写接口的所有抽象方法；
2.继承了接口的，默认方法，既可以直接调用，也可以重写。
**/
class 类名 implements 接口{//重写接口中抽象方法（必须）//重写接口中默认方法（可选）
}

注意：静态与.class相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用。代码如下：
定义接口：

public interface LiveAble{public static void run(){System.out.println("我是接口中的静态方法");}
}

定义实现类：

public class Animal implements LiveAble{//无法重写静态方法
}

定义测试类：

public class Test{//Animal.run(); //错误，无法继承方法，也无法调用LiveAble.run();//ok
}

私有方法的使用

私有方法只有默认方法可以调用
私有静态方法只有默认方法和静态方法可以调用

如果一个接口中有多个默认方法，并且代码中有重复，则可以抽象出来封装到私有方法中，供默认方法去调用。从设计的角度，私有方法是对默认方法和静态方法的辅助。

public interface LiveAble{default void func(){func1();func2();}private void func1(){System.out.println("跑起来~~~");}private void func2(){System.out.println("跑起来~~~");}
}

优先级问题

当一个类既继承父类，又实现若干个接口时，如果父类的成员方法与接口中的默认方法的方法名相同，子类就近选择执行父类的成员方法。代码如下：
定义接口：

public interface Aoo{public void methodA(){System.out.println("AAAA");}
}

定义父类：

public class Boo{public void methodA(){System.out.println("BBBB");}
}

定义子类：

class C extends Boo implements Aoo{//未重写methodA方法
}

定义测试类

public class Test{public static void main(String[] args){C c = new C();c.methodA();//输出结果：BBBB}
}

多态

多态是继封装、继承之后，面向对象的第三大特性。
多态：是指同一行为，具有多种表现形式。

前提：【重点】
1.继承或者实现【二选一】
2.方法的重写【意义体现：不重写，无意义】
3.父类引用指向子类对象。
格式：
父类类型 变量名 = new 子类对象；
变量名.方法名();

当使用多态调用方法时，先检查父类中是否含有此方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

多态可以使程序变得简单，有良好的拓展性。

引用类型的转换

多态的转型分为向上转型和向下转型两种。

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。
当父类引用指向一个子类对象时，就是向上转型。
使用格式：

父类类型 变量名 = new 子类类型();
如：Animal a = new Cat();

向下转型：
当父类类型向子类类型向下转换的过程，整个过程是强制的。
使用格式：
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

子类类型 变量名 = （子类类型） 父类变量名;
如：Cat a = （Cat）a;

转型的过程中，一不小心会遇到问题，如下：

public class Test{public static void main(String[] args){//向上转型Animal a = new Cat();a.eat();    //调用的是Cat的eat//向下转型Dog d = (Dog)a;d.watchHouse();  //调用的是Dog的watchHouse【运行报错】}
}

这段代码可以通过编译，但是运行时，却报出了ClassCastException，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换为Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

为了避免ClassCastException的发生，Java提供了instanceof关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

public class Test{public static void main(String[] args){//向上转型Animal a = new Cat();a.eat();//向下转型if(a instanceof Cat){Cat c = (Cat) a;c.catchMouse();}else if(a instanceof Dog){Dog d = (Dog) a;d.watchHouse();}}
}

java是值传递的

值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

程序执行的顺序：先new成员变量，再new构造方法等

基本类型与包装类型

基本类型保存在栈中方便高效存取，包装类型需要通过引用指向实例，存在堆中
与集合类型使用时只能使用包装类型
Java中的包装类包括：Integer、Long、Short、Byte、Character、Double、Float、
Boolean、BigInteger、BigDecimal。其中BigInteger、BigDecimal没有相对应的基本类型，主要应用于高精度的运算，BigInteger支持任意精度的整数，BigDecimal支持任意精度带小数点的运算。
在java中，一切皆对象。但八大基本类型不是对象
基本类型无需new来创建，而包装类型需要new来创建