java自学杂记＜一＞

构造方法：构造方法名称与类同名，一个类可以有多个构造方法

变量：

局部变量（方法/构造方法/语句块中的）成员变量（定义在类中，方法体之外，创建对象的时候实例化）类变量（类中的，方法体之外，static类型）

基本数据类型：

a: 内置数据类型（六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型）
byte(空间是int的四分之一) short(空间是int的二分之一) int long(用在较大整数) float double boolean char(任何字符串)

b: 引用数据类型

常量： final修饰

变量：

类变量（独立于方法外，static修饰） 实列变量（独立方法外） 局部变量（类中方法中的）
a：局部变量：没有默认值，必须初始化；访问修饰符不可用
b：实列变量：至少被一个方法/构造方法或语句块引用，是的外部能通过这些方式获取实例变量；访问修饰符可用；public对子类可见，private对子类不可见
c：类变量（静态变量 static） 经常被声明为常量，初始化后不可改变；被声明为public static final类型时，名称用大写

修饰符：

a：访问修饰符
default private public protected(对其所在类的子类可见)
b：非访问修饰符
static final
abstract：
A. 抽象类
1）抽象类不能实例化，为了将来对该类扩充
2）一个类包含抽象方法，该类一定要声明为抽象类
3）可以包含抽象方法和非抽象方法
B. 抽象方法
1）没有任何实现的方法，该方法的具体实现由子类提供
2）不能被声明为final static
3)任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类
4）如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法

Character类：

对单个字符进行操作
isLetter() 是否是一个字母
isDigit()是否是 一个数字字符

数组：

声明：double[] list = new double(10) 或 double list = {1,2,3}
for-each循环：
for(double element: list) { // do sth.}

StringBuffer/StringBuilder类：

对字符串进行修改时用

日期时间：

日期比较： before() / after() / equals()
格式化日期： new SimpleDateFormat(“yyyy-MM-dd hh:mm:ss”).format(要格式化的时间)

sleep() 使当前线程进入停滞状态（阻塞当前线程）

异常处理：

类型： 用户输入非法数据/要打开的文件不存在/网络通信终端或内存溢出

检查性异常：用户错误或问题引起的，无法预见的，编译时不能被简单忽略
运行时异常：可避免的，可在编译时忽略
错误：不是异常，而是脱离控制的问题

Exception类：
所有异常类时从java.lang.Exception类继承的子类
Exception是Throwable类的子类。Throwable类还有一个子类Error(用于运行时环境发生的错误)

Exception类的子类为：IOException / RuntimeException

继承：不支持多继承但支持多重继承

关键字：
①extends->只能继承一个类
②implements-> 多继承 public class C implements A,B {…} C继承A和B（使用该范围为类继承接口的情况，可同时继承多个接口）
③super：对父类成员的访问 super.父类的方法()
④final：声明的类不能被继承，修饰的方法
构造器：
子类不继承父类的构造器（构造方法或构造函数），只是调用,初始化父类成员属性。若父类的构造器带有参数，则必须再子类的构造器中显示的通过super调用父类的构造器并传参数。
若父类构造器没有参数，子类的构造器用不需要用super调父类的构造器，系统会自动调父类的无参构造器。

构造器-what:
名称与类名相同，没有返回值，不能写void
可以重载
若没有手动添加，会有默认的无参构造器
若手动添加了，默认的会消失

构造器-作用：为正在创建的对象的成员变量赋初始值
构造方法在创建对象时调用，具体调用哪一个是参数决定的
public class Student {
public Student() { // 无参构造器}
public Student(int a) { // 一个参数构造器} ->可以在构造函数中给Student的成员变量赋值
public Student(int a， String s) { // 两个参数构造器}
}

调用：
Student s1 = new Student() // 无参构造器
Student s2 = new Student(15) // 调一个参数构造器
Student s3 = new Student(15, ‘aa’) // 调两个参数构造器

构造方法-this：表示刚刚创建的对象，可访问对象属性，实例方法，调用重载的其他构造方法(只能在第一行)
public class Student {
public int age
public Student() {
this(15) -> 调用了具有int类型参数的构造器，重载构造器不可同时相互调用，避免陷入死循环
}
public Student(int a) {
thia.age = a
}
}

重写(overide)/重载(overload)

重写：子类对父类的允许访问的方法重新编写，返回值和形参都不能改变。外壳不变，核心重写。
子类根据需要实现父类的方法
重写不能抛出新的检查异常或比原先更加宽泛的异常

重写规则：
声明为final的方法不可重写
声明static的方法不可重写，但能再次声明
子类和父类在同一个包中，子类可重写父类所有方法，除private和final的
子类和父类不在同一个包中，子类只能重写父类声明为public和protected的非final方法
重写的方法可抛出任何非强制异常，无论被重写的方法是否抛出异常，但是，重写的方法不能抛出新的强制性异常，或者比原先更广泛的强制性异常
构造方法不能被重写
如果不能继承一个类，则不能重写该类的方法

super的使用：需要在子类中调用父类的被重写方法时用

重载：在一个类里，方法名称相同，参数不同。返回类型可相同或不同
每个重载的方法必须有独一无二的参数
最常见的是构造器重载

重载规则：
被重载的方法必须改变参数(个数或类型不一样)
被重载的方法可改变返回类型
被重载的方法可改变访问修饰符
被重载的方法可声明新的或更广的检查异常
方法能在同一个类中或一个子类中被重载
无法以返回值类型作为重载函数的区分标准

重写和重载的区别：重写是子类与父类的一种多态性表现；重载是一个类的多态性表现
参数：必须修改/一定不能修改
返回类型：可修改/一定不能修改
异常：可修改/可减少或删除，一定不能抛出新的或更广的异常
访问：可修改/一定不能做更严格的限制，可降低限制

多态：

三个必要条件：继承，重写，父类引用指向子类对象：Parent p = new Child()
public class Test {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dog()); // 以 Dog 对象调用 show 方法

  Animal a = new Cat();  // 向上转型  
  a.eat();               // 调用的是 Cat 的 eat
  Cat c = (Cat)a;        // 向下转型  
  c.work();        // 调用的是 Cat 的 work

}

public static void show(Animal a)  {
  a.eat();  
    // 类型判断
    if (a instanceof Cat)  {  // 猫做的事情 
        Cat c = (Cat)a;  
        c.work();  
    } else if (a instanceof Dog) { // 狗做的事情 
        Dog c = (Dog)a;  
        c.work();  
    }  
}  

}

abstract class Animal {
abstract void eat();
}

class Cat extends Animal {
public void eat() {
System.out.println(“吃鱼”);
}
public void work() {
System.out.println(“抓老鼠”);
}
}

class Dog extends Animal {
public void eat() {
System.out.println(“吃骨头”);
}
public void work() {
System.out.println(“看家”);
}
}

总结：根据传入的对象类型实例化对应类型的对象，再调用此对象的方法

当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法
若想调用父类中被重写的方法，用super

多态的实现方式：重写/接口(一些方法特征的集合，但没有方法的实现)/抽象类和抽象方法

抽象类：不能实例化对象，必须被继承才能使用

public abstract class Studeng{ … }

抽象方法：只有方法名，没有方法体
如果一个类有抽象方法，该类必须是抽象类
继承抽象方法的子类必须重写该方法，否则，该子类也必须声明为抽象类

总结：
抽象类不能实例化
抽象类中不一定包含抽象方法，但是又抽象方法的类一定是抽象类
抽象类中的抽象方法只是声明，没有方法体
构造方法，类方法(用static修饰的方法)不可声明为抽象方法
抽象类的子类必须给抽象类中的抽象方法的具体实现，除非该子类也是抽象类

封装

接口：抽象类型，是抽象方法的集合。不是类

接口不能实例化
接口没有构造方法
接口中所有方法必须是抽象方法
接口不能包含成员变量，除了static和final变量
接口不是被类继承，而是要被类实现
接口支持多继承

抽象类和接口的区别：
抽象类中的方法可有方法体，接口中的不行
抽象类中的成员变量可以是各种类型的，接口中的成员变量只能是public static final类型的
接口中不能有静态代码块及静态方法（用static修饰的方法），抽象类是可以有的
一个类只能继承一个抽象类，但一个类可实现多个接口

public class 类名 implements 接口名{ … }

标记接口：没有任何方法和属性的接口，

枚举enum

enum Color { RED, GREEN, BLUE }

迭代：
for(Color val: Color.values()) {
Synstem.out.println(val)
}

values() 返回枚举类中所有值
ordinal()找到每个枚举常量的索引
valueOf()返回指定字符串值得枚举常量

枚举可以用变量，方法（具体or抽象）和构造函数，构造函数只能用private，如果有抽象方法，每个实例都必须实现它

实例
Color c1 = Color.RED

包package

ArrayList类：可动态修改的数组

引入 import java.util.ArrayList
ArrayList list = new ArrayList()
add(‘xx’)添加元素
get(索引) 获取元素
set(索引，值) 修改元素
remove(索引) 删除元素
size()获取长度
sort() 排序 要引入Collections类(import java.util.Collection) Collection.sort(list)
迭代：
for循环或for-each:
for (String i: list) {
…
}

链表LinkedList:

单选链表：包含当前节点的值和一个指向下一个节点的链接
双向链接：包含数值，向后的节点链接，向前的节点链接
增加和删除比ArrayList的效率高，查找和修改效率低

使用ArrayList的情况：
频繁访问列表中的某个元素
只需要在列表末尾进行添加和删除元素

使用LinkedList的情况：
需要通过循环迭代访问列表中的某些元素
需要频繁在列表开头，中间，末尾进行添加和删除元素

import java.util.LinkedList
LinkedList list = new LinkedList()

addFirst(值) 头部添加元素
addLast(值) 尾部添加元素
removeFirst() 移除头部元素
removeLast() 移除尾部元素
getFirst() 获取头部元素
getLast() 获取尾部元素
size() 获取数量

迭代同ArrayList

HashSet: 不允许又重复元素的集合

可以又null, 不会记录插入的顺序
add(‘xx’)添加元素
remove(值) 删除元素
clear() 删除所有元素
size() 获取数量
contains(值) 判断是否存在

迭代：for-each

HashMap: 键值对

最多允许一条记录键为null,不会记录插入的顺序
put(键, 值) 添加
get(键) 获取
remove(键) 删除
clear() 删除所有
size() 获取数量

迭代：for-each
for(Integer i: list.keySet()) {
// i为key
}
for(Integer value: list.values()) {
//value为值
}

迭代器Iterator： 不是集合，是用于访问集合的方法，可用于迭代ArrayList和HashSet

it.next() 返回迭代器的下一个元素
it.hasNext() 检查集合中是否还又元素
it.remove() 将迭代器返回的元素删除

获取一个迭代器：
ArrayList list = new ArrayList()
Iterator it = list.iterator()

循环：
white(it.hasNext()) {
// 可输出每个元素 it.next()
}

Object类：是所有类的父类