java基础

流程控制
核心类
泛型与集合
异常
- Throwable类
面向对象
基础语法

流程控制

循环结构

while循环
do…while循环
for循环
- for-each循环

分支结构

if…else
switch…case…default

顺序结构

关键字

break
循环结束，跳出循环体
continue
跳出本次循环

核心类

基本类型的封装类

基本数据类型封装类描述
byte Byte 字节
short Short 短整型
int Integer 整型
long Long 长整型
char Character 字符型
float Float 单精度浮点型
double Double 双精度浮点型
boolean Boolean 布尔型

基本数据类型与封装类的转换

基本类型——>封装类
通过new封装类(值)创建
封装类——>基本数据
通过封装类.xxxValue()方法

object类

是顶级父类

.equals()方法
equals()方法用于比较两个对象的内容是否相同
“==”运算符比较的是两个对象地址是否相同，即引用的是同一个对象
toString()方法
Object类中的toString()方法返回包含类名和散列码的字符串，具体形式如下：
类名@哈希代码值

字符串类

①String创建的字符串是不可以变的
②StringBuffer创建的字符串是可以变的，当StringBuffer创建的一个字符串的内容可以通过append()、insert()等方法改变，线程安全。
③StringBuilder也可改变字符串的内容，StringBuilder是线程不安全的，但性能较好。

Scanner类

Scanner扫描器在java.util包中，可以获取客户从键盘上输入的不同数据

Math和date类

math类是数学库,包含常用的数学函数,如sqrt/sin/cos等
date类处理日期用

泛型与集合

集合

就像是一种容器。用于存储、获取、操作对象的容器。

特点
①集合的长度是可变的
②集合可以存储任意类型的对象
③集合只能存储对象
Collection 集合（接口）
集合层次的根接口
- List集合（接口）
  有序的，可以重复的
  - ArrayList
    采用数组结构存储元素。查询操作多时选择
  - LinkedList
    采用链表结构存储元素。增删操作多时选择
  - Vector
- Set集合（接口）
  无序的，不允许重复
  - HashSet
    是 Set 接口的典型实现类
    先比较 hashCode 值，若 hashCode 存在，再通过 equals() 比较内容若 hashCode 值不存在，则直接存储
    - LinkedHashSet
      相较于 HashSet 多了链表维护元素的顺序。遍历效率高于 HashSet ，增删效率低于 HashSet
  - TreeSet
    拥有自己排序方式
    - 自然排序（Comparable）
      ①需要添加 TreeSet 集合中对象的类实现 Comparable 接口
      ②实现 compareTo(Object o) 方法
    - 定制排序（Comparator）
      ①创建一个类实现 Comparator 接口
      ②实现 compare(Object o1, Object o2) 方法
      ③将该实现类的实例作为参数传递给 TreeSet 的构造器
- Map集合（接口）
  用于存储成时对象的集合。具有 key(键)-value(值)对映射关系的集合。一个 key 对应着一个 value。 key不允许重复的
  - HashMap
    是 Map接口的典型实现类
    - LinkedHashMap
      相较于 HashMap 多了链表维护元素的顺序
  - Hashtable
    是线程安全的，因此效率低
    - Properties 用于操作属性文件
  - TreeMap
    根据 key 拥有自己的排序方式
    - 自然排序（Comparable）
    - 定制排序（Comparator）
- 集合的遍历
  - for 循环 ``` for(被遍历集合中元素的数据类型变量名 : 被遍历的集合){

} ```

Iterator 迭代器
//获取当前集合的迭代器
Iterator it = al.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}

ListIterator 列表迭代器，是List特有的迭代器

通配符？

虽然 Person 是 Student 的父类，但是 List 就不是 List 的父类
//需求：
//public void show(List list){

}
//public void show1(List list){

}
public void show(List<? extends Person> list){

}
List<?> : 可以接收任意带泛型类型的集合
List<? extends Person> : 可以接收 Person 本类类型及 Person子类类型带泛型类型的集合
List<? super Person> : 可以接收 Person 本类类型及 Person父类类型带泛型类型的集合

泛型

引入的原因
若集合中不使用泛型，意味着集合中可以添加任意类型的对象。若需要具体到某一个类型时，需要强制类型转换可能引发 ClassCastException
定义
在 Java 中以 “<>” 的形式呈现，<> 中写引用数据类型用于限制集合中存放元素的类型
自定义泛型类、接口、方法
class DAO{
// T : Type E:Element K:Key V:Value
private List list = new ArrayList();
public void add(T t){
list.add(t);
}
public T get(int id){
return list.get(id);
}
//自定义泛型方法
public E[] srot(E[] e){
}
}

异常

Throwable类

异常的顶级类，所有的异常处理机制都继承它

Error类
对于所有的编译时期的错误以及系统错误都是通过Error抛出的。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。
Exception类
规定的异常是程序本身可以处理的异常。异常和错误的区别是，异常是可以被处理的，而错误是没法处理的。
- IOException
  可检查的异常，这是编码时非常常用的，所有checked exception都是需要在代码中处理的。它们的发生是可以预测的，正常的一种情况，可以合理的处理。比如IOException，或者一些自定义的异常。除了RuntimeException及其子类以外，都是checked exception。
  - 异常处理
    - 通过try…catch语句块来处理
      try
      {
      // 程序代码
      }catch(ExceptionName e1)
      {
      //Catch 块
      }
      catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。
      如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样
      - finally关键字
        finally 关键字用来创建在 try 代码块后面执行的代码块。
        无论是否发生异常，finally 代码块中的代码总会被执行。
        在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。
    - 通过throws/throw抛出到上层再进行处理
      如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。
- RuntimeException
  RuntimeException及其子类都是unchecked exception。比如NPE空指针异常，除数为0的算数异常ArithmeticException等等，这种异常是运行时发生，无法预先捕捉处理的。Error也是unchecked exception，也是无法预先处理的。

面向对象

特征

封装
- 隐藏一切可隐藏的实现细节，只暴露一些简单的编程接口
继承
- 定义
  - 从已有类创建新类的过程叫继承
  - 提供信息的叫父类（基类或超类）
  - 得到继承信息的类叫子类（或派生类）
    子类继承父类中public或protected的属性和方法
- 继承形式
  - java中的继承都是单继承
    [访问符] [修饰符] class 子类 extends 父类{
    …
    }
多态
- 定义
  - 同样的引用调用同样的方法却干了不同的事情，多用于子类重写父类
- 重写规则
  1.方法名以及参数列表必须完全相同；
  2.子类方法的返回类型与父类保持一致，或是父类方法返回值类型的子类。
  3.子类方法声明的异常与父类保持一致，或是父类方法声明的异常的子类。
  4.父类中的私有方法不能被子类重写，如果在子类中定义了与父类重名的私有方法，则该方法只是子类的一个新方法，与父类中的私有方法无关。
  5.子类方法的可访问性必须与父类方法的可访问性保持一致，或是更加公开。
  6.不能重写静态方法。

访问控制

Private（当前类访问的权限）
被声明为private的成员只能被当前类中的其他成员访问，不能在类外看到
默认friendly（包访问权限）
如果一个类或类的其他成员前没有任何的访问控制符，则获得默认friendly访问的权限，默认可以被同一包中的所有访问类访问
protected(子类访问权限)
可以被同一包中的其他类访问，也可以被不同包中的子类访问
public（公共访问类）
不同包和同一包中都可使用

类

基本概念
- 声明
  - [访问符][修饰符]class 类名{
    [属性]
    [方法]
    }
    访问符：public(公共)、protected(受保护)、private(私有)或默认
    修饰符：abstract(抽象的)、static(静态的)、final(最终的)
    在类的声明中，修饰符不是不需要的，根据类的特征选择
- 定义
  - 类名对象名=new 类名()
    对象的两个作用：
    a. 访问对象的属性，即对象的实例变量，格式：对象名.属性名
    b. 调用对象的方法，格式：对象名.方法名()
- 方法
  - [访问符] [修饰符] <返回类型> 方法名（[参数列表]）{
    //方法体
    }
- 构造函数
  - [访问符] 类名（[参数列表]）{
    //初始化语句；
    }
    构造方法的方法名与类名一致，没有任何的返回值类型，即使是void也不行，构造方法用于创建对象时初始化对象中的属性
- 方法重载
  - 如果一个类中包含两个或两个以上方法的方法名相同，但参数列表不同，则称为方法的重载
    原则：a.在同一个类中；
    b.方法名相同；
    c.参数列表不同，及参数的个数或对应位置上的类型不同
静态成员
- 静态成员则可以直接通过类名调用
  类名.属性、类名.方法，无需通过声明的实例对象进行访问
对象数组
- 类名[] 数组名=new 类名[长度]；
  对象数组与普通数组的区别：对象数组需要new两遍，第一遍new 对象数组的长度，第二遍实例化每个对象数组的元素。
抽象类
用关键字abstract 修饰，
抽象类不能被实例化，可以通过父类指向子类的形式实例化
抽象类类似与半成品
如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法，或者声明自身为抽象类。
继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。
- 抽象方法
  抽象方法没有方法体
类之间的关系
- 继承
  - 泛化
  - 实现
- 关联
  - 关联
  - 聚合
  - 合成
- 依赖
- 内部类
  - 成员内部类
    在“外部类”的内部定义了一个类，结构简单
    例如：Cow.java
    public class Cow{
    属性；
    方法；
    Private class CowLeg{
    属性；
    方法；
    }
    }
  - 局部内部类
    在方法中定义的内部类称为局部内部类，局部变量和局部类不能用private,public等访问修饰符进行声明，它的作用被限制在声明该类的方法块中，不仅可以访问包含它的外部类的成员，还可以访问局部变量，但这些变量必须被final修饰。
  - 静态内部类
    使用static关键字修饰的一个内部类，称为“静态内部类”，前面可以访问修饰符，必须有static修饰，只能访问外部类的静态成员。
- 单例模式
  适用情况：整个系统中生成某种类型的对象有且仅有一个。
  实现方式：
  a. 构造方法私有；
  b. 用一个私有的静态变量引用实例；
  提供一个共有的静态方法获取实例。

Lambda表达式

基本语法:
(parameters) -> expression
或
(parameters) ->{ statements; }

基础语法

数据类型

基础数据类型
- 整型
  - byte、short、int、long
- 浮点型
  - float、double
- 字符型
  - char
- 布尔型
  - boolean
引用类型
又称类类型
- 类
  - String类型
    String是一个类，不属于基本数据类型
- 接口
  - interface
- 数组
  - 相同数据类型变量的集合
- 枚举类型
  - enmu
- 空类型
  - null type

操作符

算术运算符
- 单目运算符
  - ++、—
- 双目运算符
  - +、-、*、/、%
- 三目运算符
  - ？
赋值运算符
- 简单运算符
  - =
- 复合运算符
  - +=、-=、*=、/=、%=
关系运算符
- ==、！=、>、<、>=、<=
逻辑运算符
- &&、||、！
优先级
通常都是从左到右，从里到外

标识符

字母、数字、下划线、$、
数字不能开头

XMind - Trial Version