逻辑运算符
逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型。比较简单简略带过。
移位运算
移位运算符有三个: << >> >>> ，都是二元运算符，且都是按照二进制比特位来运算的。
1、 左移 <<: 最左侧位不要了, 最右侧补 0.
注意：向左移位时，丢弃的是符号位，因此正数左移可能会编程负数
2、 右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)
3、 无符号右移 >>>: 最右侧位不要了, 最左侧补 0
逻辑控制
这里我们学习了if、if…else、switch语句，还有for、while、do…while循环等。
我们要注意：主要是判断条件，就一定是布尔表达式。
还要注意switch的参数的数据类型有哪些。
switch的括号内只能是以下类型的表达式：
基本类型：byte、char、short、int，注意不能是long类型
引用类型：String常量串、枚举类型
方法
java中把函数叫做方法，它是完成某个功能，模块化的组织代码。
方法的重载与重写
着重强调方法的重载、重写，以及这两者的区别。
重载特点:
方法名相同，参数列表不同（顺序、数据类型、个数），返回值不做要求。
注意：子类也可以重载父类的方法。
重写特点:
方法名相同，参数列表相同（顺序、数据类型、个数），返回值相同（除非可以构成父子类关系）。
注意：
private 修饰的方法不能重写
static 修饰的方法不能重写
被final修饰的方法不能重写
子类重写方法后，访问权限要大于等于父类的访问权限。
区别：
关于递归
一个方法在执行过程中调用自身, 就称为 “递归”。
递归的必要条件：
- 将原问题划分成其子问题，注意：子问题必须要与原问题的解法相同
- 递归出口（设置条件，在合适的位置结束递归，否则会无限递归）
递归的程序的执行过程不太容易理解, 要想理解清楚递归, 必须先理解清楚 “方法的执行过程”, 尤其是 “方法执行结束之后, 回到调用位置继续往下执行”.
数组
定义：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。
数组在java中是引用类型。
注意：数组可以作为参数和返回值：
操作数组的工具类：Arrays
二维数组
二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组。
数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };
例如：
public static void main(String[] args) {
int[][] arr = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
for(int row = 0; row < arr.length; row++) {
for (int col = 0; col < arr[row].length; col++) {
System.out.printf("%d\t", arr[row][col]);
}
System.out.println("");
}
}
输出：
1 2 3 4
5 6 7 8
9 10 11 12
二维数组就类似于一个特殊的一维数组，每个元素相当于一个一维数组，每个一维数组的大小可以不同。
类和对象
什么是类？
类就是描述某个对象的一些属性和行为。
成员变量
成员变量定义在方法的外部，类的内部。
普通成员变量：
属于对象的，对象的引用与点号的结合进行访问，所占用的内存是在对象中的。
静态成员变量：
加static关键字，表面当前成员变量是属于类的变量。类变量是存放在方法区的。
成员方法
普通成员方法：属于对象的，对象的引用与点号的结合进行访问。
静态成员方法：不依赖于对象，直接可以通过类名点出来。
注意：不能在静态方法中使用非静态成员变量。（因为非静态成员变量依赖于对象）
对象
通过描述，产生一个真正的实体对象，主要通过new关键字来实例化对象。
一个类可以实例化多个对象。
this 关键字
this是当前对象的引用，三种用法：
1.引用当前对象的变量：this.data
2.引用当前对象的方法：this.fun()
3.引用当前对象的构造方法：this()
构造方法
方法名与类名一样，没有返回值。
作用：实例化对象的时候调用，同时可以初始化我们的成员变量。
我们有两种初始化：
就地初始化：创建变量时赋值。
默认初始化：创建变量时不赋值。（变量是默认值，不同数据类型默认值是不同的）
当我们没有添加任何构造方法时，编译器会帮我们提供一个不带参数的构造方法，而当我们添加了构造方法时，编译器就不会再提供构造方法了。
注意：构造方法可以重载。
封装
含义：指将内部的实现细节进行了隐藏，不要让类外直接获取到我不想让它获取到的东西。从代码层面来讲，就是使用关键字private进行修饰。
我们可以使用get和set方法来对封装的数据进行访问。
代码块
普通代码块：定义在方法中的代码块。
构造代码块：定义在类中的代码块(加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。
静态代码块：使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。
new对象时，静态代码块和非静态代码块与构造方法的执行顺序：先是静态的执行（只执行一次，下次就不执行了），然后是非静态的，最后是构造方法执行。
内部类
即在类里再定义一个类。
非静态内部类
public class OutClass {
private int a;
static int b;
int c;
public void methodA() {
a = 10;
System.out.println(a);
}
public static void methodB() {
System.out.println(b);
}
class InnerClass {
int c;
public void methodInner() {
a = 100;
b = 200;
methodA();
methodB();
c = 300;
System.out.println(c);
OutClass.this.c = 400;
System.out.println(OutClass.this.c);
}
}
public static void main(String[] args) {
OutClass outClass = new OutClass();
System.out.println(outClass.a);
System.out.println(OutClass.b);
System.out.println(outClass.c);
outClass.methodA();
outClass.methodB();
System.out.println("=============实例内部类的访问=============");
OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
OutClass.InnerClass innerClass2 = outClass.new InnerClass();
innerClass2.methodInner();
}
}
注意：
- 外部类中的任何成员都可以在实例内部类方法中直接访问
- 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
- 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员 来访问
- 实例内部类对象必须在先有外部类对象前提下才能创建
- 实例内部类的非静态方法中包含了一个指向外部类对象的引用
- 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。
静态内部类
被static修饰的内部成员类称为静态内部类。
public class OutClass {
private int a;
static int b;
public void methodA(){
a = 10;
System.out.println(a);
}
public static void methodB(){
System.out.println(b);
}
static class InnerClass{
public void methodInner(){
b =200;
methodB();
}
}
public static void main(String[] args) {
OutClass.InnerClass innerClass = new OutClass.InnerClass();
innerClass.methodInner();
}
}
注意：
- 在静态内部类中只能访问外部类中的静态成员
- 创建静态内部类对象时，不需要先创建外部类对象
总结：如果设计的内部类依赖于外部类对象，那就设计成非静态的内部类，反之就设计成静态内部类。
还有一个匿名内部类，就是没有名字的内部类，多用于接口的实现。
继承和多态
继承
class A extends B {
}
为什么要继承呢？
继承是共性的抽取，从而达到对代码的复用。
子类继承父类的所有成员变量和方法（非静态的）。
super 关键字
该关键字主要作用：在子类方法中访问父类的成员。
super 的几种用法：
访问父类的成员变量：super.data
访问父类的方法：super.func()
调用父类的构造方法：super()
super 与 this 的区别
super和this都可以在成员方法中访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那它们之间有什么区别呢？
同：
- 都是Java中的关键字
- 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
- 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在
异：
- this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用
- 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
- 在构造方法中：this(…)用于调用本类构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造 方法中出现
- 构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有
代码块执行顺序
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("Person：构造方法执行");
}
{
System.out.println("Person：实例代码块执行");
}
static {
System.out.println("Person：静态代码块执行");
}
}
class Student extends Person{
public Student(String name,int age) {
super(name,age);
System.out.println("Student：构造方法执行");
}
{
System.out.println("Student：实例代码块执行");
}
static {
System.out.println("Student：静态代码块执行");
}
}
public class TestDemo4 {
public static void main(String[] args) {
Student student1 = new Student("张三", 15);
System.out.println("===========================");
Student student2 = new Student("李四", 35);
}
}
输出：
1、父类静态代码块优先于子类静态代码块执行，且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行
访问修饰限定符
final 关键字
final关键可以用来修饰变量、成员方法以及类。
注意三个点：
- 修饰变量或字段，表示常量(即不能修改)
- 修饰类：表示此类不能被继承
- 修饰方法：表示该方法不能被重写
多态
啥是多态?
就是一个引用,引用的对象不一样, 所表现的行为不一样, 这种思想被称为多态.
向上转型
class Animal {
}
class Cat extends Animal {
}
父类类型引用子类对象, 这便是向上转型.
Animal animal = new Cat();
缺点 : 只能通过父类引用 访问父类自己的成员.
什么时候发生向上转型呢?
第一种就是直接赋值了 :
Animal animal = new Cat();
还有就是方法的传参 , 就是将子类对象传入父类类型参数里 :
public static void fun(Animal animal) {
}
再就是方法的返回值了 :
public static Animal fun(Animal animal) {
return new Cat();
}
关于动态绑定 : 通过父类引用 , 调用子类重写了的父类的方法.
抽象类和接口
抽象类
抽象类语法
public abstract class A {
abstract public void fun();
abstract void func();
public double funcc(){
return m;
}
protected double f;
}
抽象类也是类，内部可以包含普通方法和属性，甚至构造方法
抽象类特性
- 抽象类不能直接实例化对象
- 抽象方法不能是 private 的
- 抽象方法不能被final和static修饰，因为抽象方法要被子类重写
- 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰
- 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
- 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量
抽象类作用
抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类， 然后让子类重写抽象类中的抽象方法，使用抽象类相当于多了一重编译器的校验。
接口
接口语法
public interface 接口名称，接口名称...{
public abstract void method1();
public void method2();
abstract void method3();
void method4();
}
接口使用
接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。
注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。
接口间的继承
类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字。
接口间的继承相当于把多个接口合并在一起，不需要去实现接口中的方法。
接口特性
- 接口类型是一种引用类型，但是不能直接new接口的对象
- 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错)
- 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现
- 重写接口中方法时，不能使用默认的访问权限 (因为接口中的方法默认为 public abstract)
- 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
- 接口中不能有静态代码块和构造方法
- 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
- 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
- jdk8中：接口中还可以包含default方法
注意 :
一个类可以实现多个接口 (继承是只能继承一个)
一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。（ IDEA 中使用 ctrl + i 快速实现接口）
抽象类和接口的区别
核心区别:
抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.
String
字符串构造的常用三种方法
public static void main(String[] args) {
String s1 = "hello world";
System.out.println(s1);
String s2 = new String("hello world");
System.out.println(s1);
char[] array = {'h','e','l','l','o','w','o','r','l','d'};
String s3 = new String(array);
System.out.println(s1);
}
String对象的比较
1.比较是否引用同一个对象
对于内置类型，== 比较的是变量中的值；对于引用类型，比较的是引用中的地址。
- boolean equals(Object anObject) 方法：按照字典序比较（字符大小的顺序）
String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后，按照如下规则进行比较，比如： s1.equals(s2)
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
- int compareTo(String s) 方法: 按照字典序进行比较
与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：
- 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
- 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("abc");
String s4 = new String("abcdef");
System.out.println(s1.compareTo(s2));
System.out.println(s1.compareTo(s3));
System.out.println(s1.compareTo(s4));
}
- int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("ABc");
String s4 = new String("abcdef");
System.out.println(s1.compareToIgnoreCase(s2));
System.out.println(s1.compareToIgnoreCase(s3));
System.out.println(s1.compareToIgnoreCase(s4));
}
StringBuilder和StringBuffer
由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。这两个类大部分功能是相同的.
String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改。频繁修改字符串的情况考虑使用StringBuilder.
注意：String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:
String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
StringBuilder变为String: 调用toString()方法
String、StringBuffer、StringBuilder的区别:
String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.
StringBuffer与StringBuilder大部分功能是相似的
StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作
异常
异常的体系结构
异常种类繁多，为了对不同异常或者错误进行很好的分类管理，Java内部维护了一个异常的体系结构：
- Throwable：是异常体系的顶层类，其派生出两个重要的子类, Error 和 Exception
- Error：指的是Java虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等，典型代表：
StackOverflowError和OutOfMemoryError，一旦发生回力乏术。
- Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。比如：感冒、发烧。我们平时所说的异常就是Exception。
异常分类
- 编译时异常
在程序编译期间发生的异常，称为编译时异常，也称为受查异常
- 运行时异常
在程序执行期间发生的异常，称为运行时异常，也称为非受查异常
RunTimeException以及其子类对应的异常，都称为运行时异常。比如：NullPointerException、ArrayIndexOutOfBoundsException、ArithmeticException。
异常抛出
借助throw关键字，抛出一个指定的异常对象，将错误信息告知给调用者。
throw new XXXException("异常产生的原因");
注意：
- throw必须写在方法体内部
- 抛出的对象必须是Exception 或者 Exception 的子类对象
- 如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理
- 如果抛出的是编译时异常，用户必须处理，否则无法通过编译
- 异常一旦抛出，其后的代码就不会执行
异常的捕获
主要有两种：异常声明throws 以及 try-catch捕获处理。
异常声明throws
处在方法声明时参数列表之后，当方法中抛出编译时异常，用户不想处理该异常，此时就可以借助throws将异常抛给方法的调用者来处理。即当前方法不处理异常，提醒方法的调用者处理异常。
修饰符 返回值类型 方法名(参数列表) throws 异常类型1，异常类型2...{
}
注意：
- throws必须跟在方法的参数列表之后
- 声明的异常必须是 Exception 或者 Exception 的子类
- 方法内部如果抛出了多个异常，throws之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常类型具有父子关系，直接声明父类即可。
- 调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出
try-catch捕获并处理
throws对异常并没有真正处理，而是将异常报告给抛出异常方法的调用者，由调用者处理。如果真正要对异常进行处理，就需要try-catch.
try{
}catch(要捕获的异常类型 e){
}[catch(异常类型 e){
}finally{
}]
注：
- [ ]中表示可选项，可以添加，也可以不用添加
- try中的代码可能会抛出异常，也可能不会
注意：
- try块内抛出异常位置之后的代码将不会被执行
- 如果抛出异常类型与catch时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后 中断程序----异常是按照类型来捕获的
- try中可能会抛出多个不同的异常对象，则必须用多个catch来捕获----即多种异常，多次捕获
- 可以通过一个catch捕获所有的异常，即多个异常，一次捕获(用它们的父类异常捕获，如果这样做我们就不知道发生了什么异常，因此不推荐)
在catch 语句里我们有三种处理异常方法：
只打印异常信息：System.out.println(e.getMessage());
打印异常类型，异常信息：System.out.println(e);
打印信息最全面：e.printStackTrace();
finally
try{
}catch(异常类型 e){
}finally{
}
finally中的代码一定会执行的，一般在finally中进行一些资源清理的扫尾工作。
自定义异常
Java 中虽然已经内置了丰富的异常类, 但是并不能完全表示实际开发中所遇到的一些异常，此时就需要维护符合我们实际情况的异常结构。
实现方式：
- 自定义异常类，然后继承自Exception 或者 RunTimeException
- 实现一个带有String类型参数的构造方法，参数含义：出现异常的原因
注意：
自定义异常通常会继承自 Exception 或者 RuntimeException
继承自 Exception 的异常默认是受查异常
继承自 RuntimeException 的异常默认是非受查异常
举个例子，实现一个用户登录功能：
public class Test {
public static void fun(String name2, String code2) throws PasswordException, UsernameException {
String name = "张三";
String code = "666666";
if(!name2.equals(name)) {
throw new PasswordException("用户名错误!");
}
if(!code2.equals(code)) {
throw new UsernameException("密码错误！");
}
System.out.println("输入成功！！！");
}
public static void main(String[] args) throws PasswordException, UsernameException {
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
String code = scanner.nextLine();
fun(name,code);
}
}
public class PasswordException extends Exception{
public PasswordException(String message) {
super(message);
}
}
public class UsernameException extends Exception{
public UsernameException(String message) {
super(message);
}
}
