常用的API一

Scanner in=new Scanner（System.in）
匿名对象
Random random=new Random()
ArrayList集合 ArrayList list=new ArrayList<>()

String类

对于String str=”wx”,str=”JAVA”,这没有改变字符串的值，只是改变了str的地址值
字符串的值是常量，不能改变.字符串底层就是由字节数组byte[] 来实现的
字符串创建的几种方式
1、String str=”hello”
2、String str=new String()
3、String str=new String(char[] array)
4、String str=new String(byte[] b)
字符串常量池
字符串常量池，直接用双引号创建的字符串，就在常量池中对于基本类型 ==是进行数值的比较对于引用类型 ==是进行数值的比较

equals方法：

推荐写法：System.out.println(“abc”.equals(str2));防止str2为null出现空指针异常
equalsIgnoreCase方法：
和equals的区别是不区分大小写

1.获取字符串长度方法length
2.连接字符串方法concat
3.得到字符串指定位置字符方法charAt
4.得到小串在大串中第一次出现的位置方法indexOf，没有的话放回-1
索引是从0开始的

从字符串中的到子串的方法
1、substring(int x)—>从x位置截取到末尾形成的子串
2、substring(int begin,int end)—>从begin到end截取子串不包括end —>[begin,end)

1、字符串转字符数组toCharArray
2、字符串转字节数组getBytes
3、用新串代替字符串某些位置，游戏里的文明交流就用到这个replace(old,new)

字符串分割方法—>split

static关键字

修饰成员变量或者成员方法的调用形式，不能是局部变量
类名称.成员变量
类名称.成员方法
静态不可以直接访问非静态，因为静态是不创建类就可以直接用的，所以静态里不能有非静态。而非静态是可以直接访问非静态的。
静态方法不能使用this
静态代码块：用途：一次性的对静态成员变量进行赋值
本类第一次被用到时才执行唯一一次，静态优先于非静态，所以static块比构造方法先执行

Arrays数组工具类

toString方法和sort方法
也可对char型数组排序

Math数学工具类

1、绝对值
2、取最大值
3、向上取整
4、向下取整
5、四舍五入
6、圆周率PI值

继承

加入父类和子类有相同的成员变量和方法，子类创建对象去访问这些同名的变量和方法，子类对象首先会在自己里面找，找到就用自己的，找不到就向上找。
当局部变量、子类成员变量、父类成员变量都有相同的名字时这样写

方法重写Override：方法名称一样，参数列表一样，子类方法返回值必须<=父类方法返回值范围，子类方法权限必须>=父类方法权限（区别重载：方法名称一样，参数列表不一样）

@Override注解:检查重写是否正确
public>protected>(default)>private (default)表示不写修饰符
super：如果在子类构造方法中，没有调用父类的构造方法，那么会默认有一个super(),并且super调用父类构造方法必须是子类构造方法的第一条语句。子类必须调用父类构造方法。有父才有子。
this：调用本类构造方法

this和super都必须是第一句
抽象方法（abstract）：如果一个方法不知如何具体实现，应该就是一个抽象方法。比如计算图形面接的方法，你不知道是什么图形不知到如何实现，但是我告诉你三角形面积，你不就会了。
抽象方法所在类必须是抽象类，但是抽象类中可以有普通方法，并且抽象类中可以没有抽象方法。
不能用抽象类直接创建对象
必须用一个子类继承抽象父类，并且重写所有抽象方法

接口(interface)—->编译之后仍然生存.class文件

接口中的抽象方法的修饰符必须是public abstract
可以省略public abstract其中一个或者两个修饰符
接口不能直接用，必须用类来实现，实现类必须重写所有的抽象方法(1、去掉abstract 2、加上方法体)

接口里的默认方法：用途—>接口升级(当接口中要添加新的方法时，会对所有的实现类都有影响，但是修改实现类不太现实，所以使用默认方法，这样接口中可以添加新的方法，又不会已经存在的实现类)可以被实现类直接调用，也可以内覆盖重写。

JAVA 8以后，允许接口中定义静态方法(通过接口名称直接调用接口中的静态方法，不能用实现类的对象来调用)

Java9以后，接口中允许有私有方法。
1、普通私有方法—>解决多个默认方法之间重复代码问题
2、静态私有方法—>解决多个静态方法之间重复代码问题
接口中常量定义：用public static final 修饰，三者都可以省略。并且必须赋值，还不能改变。大写。

接口继承是多继承
**

面试题：接口与抽象类的区别

相同点
（1）都不能被实例化 （2）接口的实现类或抽象类的子类都只有实现了接口或抽象类中的方法后才能实例化。
不同点
（1）接口只有定义，不能有方法的实现，java 1.8中可以定义default方法体，而抽象类可以有定义与实现，方法可在抽象类中实现。
（2）实现接口的关键字为implements，继承抽象类的关键字为extends。一个类可以实现多个接口，但一个类只能继承一个抽象类。所以，使用接口可以间接地实现多重继承。
（3）接口强调特定功能的实现，而抽象类强调所属关系。
（4）接口成员变量默认为public static final，必须赋初值，不能被修改；其所有的成员方法都是public、abstract的。抽象类中成员变量默认default，可在子类中被重新定义，也可被重新赋值；抽象方法被abstract修饰，不能被private、static、synchronized和native等修饰，必须以分号结尾，不带花括号。

多态性：一句话父类引用指向子类对象

多态写法不能使用子类特有的方法，只能使用子类重写父类的那部分方法。
格式 父类 对象名=new 子类 or 接口 对项名=new 实现类
对于变量 =号左边是谁就用谁，没有就向上找 编译看左边，运行看左边
对于方法，new 谁就用谁，没有就向上找 编译看左边，运行看右边

**利用上转型对象传参数
上转型：父类 对象名=new 子类
下转型：子类 对象名=(子类名称)父类对象 //这个父类对象是是上转型对象才能被还原回来
如：Animal animal=new Cat();
Cat cat=(Cat)animal;//animal只能被还原为Cat，而不能是Dog。
上下转型的应用和instanceof的使用 返回boolean 对象名 instanceof 类名称

final：对于类和方法，final和abstract不能同时使用因为矛盾，如 修饰方法abstract要被重写而final不能被重写
1、修饰类，这个类不能有子类
2、修饰成员方法，这个方法不能被重写
3、修饰局部变量
若是基本类型 则值不能变
若是引用类型 则地址值不能变，但是里面内容可变。
4、修饰成员变量，那么这个变量要手动赋值，不会给默认值

四种权限修饰符

        public  >   protected   >   (default)   >   private<br />同一个类        Y            Y                Y             Y<br />同包不同类       Y           Y                 Y             N<br />不同包子类       Y           Y                 N             N<br />不同包非子类      Y           N                 N             N

内部类

权限修饰符
外部类(public/(default))
成员内部类(四个都可以)
局部内部类(什么都不写)
1、成员内部类
外用内，随便用。内用外，需创建对象。
使用成员内部类有两种方式
1、直接方式 通过外部类的方法访问
2、间接方式 创建对象 外部类.内部类 对象名=new 外部类().new 内部类();
外部类和内部类有重名的变量这样访问 外部类.this.外部类成员变量

2、局部内部类(匿名内部类)
定义在方法里,并且这个方法才能使用局部内部类
**局部内部类使用所在方法局部变量，这个变量要用final修饰
匿名内部类
如果接口的实现类或者父类的子类只使用唯一的一次，那么就可以使用匿名内部类，而不用去创建实现类或者子类。
格式：接口名称 对象名=new 接口名称(){//覆盖重写所有的抽象方法};

**接口和类都可以作为变量

发红包案列：随机红包公式——>随机金额=\\random.nextInt(leftMoney/leftcount*2)+1 //leftMoney剩下的总金额 leftcount剩下要发的份数
Random random=new Random();
int leftMoney=totalMoney;
int leftCount=totalCount;
for(int i=0;i<totalCount-1;i++)
{
int money=random.nextInt(leftMoney/leftcount*2)+1;
list.add(money);
leftMoney-=money;
leftCount—;
}
list.add(leftMoney);//最后一个直接放进去

Object类

这两个方法都可以使用快捷键添加，而不用自己写
1、toString方法，没有重写的话就输出地址值，重写后就不输出地址值(可以用于判断一个类是否重写了toString方法)。
2、equals方法，Object里面的equals只能看地址=不=，若要比较对象内容是不是相同就得重写equals

Objects.equals(Object a,Object b)方法也可以比较字符串内容是否相同，还不会想字符串的equals方法可能出现空指针异常。

Date类

DateFormat类（抽象类）子类SimpleDateFormat

1、吧Date日期转化为文本

2、吧文本转为Date日期

Calendar类（抽象类）

System类

StringBuilder类(缓冲区)：提高字符串效率

String 变StringBuilder 通过构造方法
StringBuilder 变String 用toString方法
append方法(添加串)+reverse方法(字符串内容反转)

Collection集合框架

Iterator迭代器

Iterator<元素类型> it=集合对象.iterator();
hasNext()方法 next()方法 remove()方法

Iterable接口 ：实现了这个接口的对象都支持增强for循环
**

泛型

1、类使用泛型

2、方法使用泛型

3、接口使用泛型

4、泛型通配符

5、泛型上限

比如Collection<? extends Student> coll 那么？就只能是本身或者子类

6、泛型下限

比如Collection<? super Student> coll那么？就只能是本身或者父类

斗地主案列1

package cn.edu.nefu.collection;

import java.util.ArrayList;
import java.util.Collections;
//斗地主案列
public class DouDiZhu1 {
public static void main(String[] args) {
ArrayList poker=new ArrayList<>();//用来存储54张牌
//两个数组用来组合四种牌
String[] str1={“♠”,”♥”,”♣”,”♦”};
String[] str2={“3”,”4”, “5”,”6”,”7”,”8”,”9”,”10”,”J”,”Q”,”K”,”A”,”2”};
//先把特殊的大小王添加进去
poker.add(“大王”);
poker.add(“小王”);
for(String i:str1){
for(String j:str2){
poker.add(i+j);//组合4种牌
}
}
Collections.shuffle(poker);//洗牌函数
//发牌
ArrayList player1=new ArrayList<>();
ArrayList player2=new ArrayList<>();
ArrayList player3=new ArrayList<>();
ArrayList diPai=new ArrayList<>();
for (int i = 0; i < poker.size()-3; i++) {//poker.size()-3表示留下3张底牌
//轮流给三个人发牌
if(i%30){
player1.add(poker.get(i));//
}else if(i%31){
player2.add(poker.get(i));
}else{
player3.add(poker.get(i));
}
}
for (int i = poker.size()-1; i>=51; i—) {
diPai.add(poker.get(i));
}
System.out.println(“赌王的牌:”+player1);
System.out.println(“赌圣的牌:”+player2);
System.out.println(“赌神的牌:”+player3);
System.out.println(“底牌:”+diPai);
}
}

斗地主案列2

package cn.edu.nefu.collection;

import java.util.*;

public class DouDiZhu2 {
public static void main(String[] args) {
Map poker=new HashMap<>();//装扑克
List pokerIndex=new ArrayList<>();//扑克索引
List color=new ArrayList<>();
Collections.addAll(color,”♠”,”♥”,”♣”,”♦”);
List number=new ArrayList<>();
Collections.addAll(number,”2”,”A”,”K”,”Q”,”J”,”10”,”9”,”8”,”7”,”6”,”5”,”4”,”3”);
//组装牌
int index=0;
poker.put(index,”大王”);
pokerIndex.add(index);
index++;
poker.put(index,”小王”);
pokerIndex.add(index);
index++;
for(String i:number){
for(String j:color){
poker.put(index,i+j);
pokerIndex.add(index);
index++;
}
}
//洗牌
Collections.shuffle(pokerIndex);
//发牌
List player1=new ArrayList<>();
List player2=new ArrayList<>();
List player3=new ArrayList<>();
List diPai=new ArrayList<>();
for(int i=0;iif(i>=51){
diPai.add(pokerIndex.get(i));
}else if(i%30){
player1.add(pokerIndex.get(i));
}else if(i%31){
player2.add(pokerIndex.get(i));
}else{
player3.add(pokerIndex.get(i));
}
}
//排序
Collections.sort(player1);
Collections.sort(player2);
Collections.sort(player3);
Collections.sort(diPai);
look(“刘德华”,poker,player1);
look(“周星驰”,poker,player2);
look(“周润发”,poker,player3);
look(“底牌”,poker,diPai);
}
private static void look(String name,Map poker,List player){
System.out.print(name+”的牌: “);
for(Integer i:player){
System.out.print(poker.get(i)+” “);
}
System.out.println();
}
}

数据结构

1、栈

2、队列

3、数组

4、链表

5、红黑树

哈希表(速度快)=数组+红黑树

存储在Set集合中元素无序不重复的原理：当添加一个元素时，回自动调用hashCode方法计算哈希值,放入集合。但如果哈希值相同的话就会调用equals方法判断两个元素相不相同，相同则视为同一个元素，不添加进集合。
对于我们自己定义的类，必须重写hashCode方法和equals方法才行。基本包装类其实已经重写了这两个方法。
如没有重写这两个方法如下图

重写这两个方法后

LinkedHashSet

有序并且不重复

可变参数

Collections工具类

Collections.addAll()—>向集合中添加多个元素
Collections.shuffle()—>打乱集合
Collections.sort(list)—>排序

Collections使用Lambda表达式排序

_

Map集合:

key唯一,value重复。当key重复时，会用新的value去代替原来的value值如下图

put(key,value) remove(key) get(key) containsKey(key)

keySet()方法(set集合)

使用迭代器遍历Map

增强for遍历Map

当使用自定义类作为Map的key时，为了保证key唯一，在自定义类里必须重写hashCode方法和equals方法，还有就是当要输出自定义类的对象时，要重写toString方法。
注意：key张三那个重复了，然后用value重庆代替了value北京

LinkedHashMap—>有序集合

用Map统计一个字符串中各个字符的个数

Debug追踪

异常

以后(在工作中)我们首先必须对方法传递过来的参数进行合法检验，如果参数不合法，我们就必须使用抛出异常的方式，告知方法的调用者，传递过来的参数有问题
Throwable 类是 Java 语言中所有错误或异常的超类。
Error类错误：必须修改代码才能运行
Exception编译期异常—>必须处理
RuntimeException运行期异常—>可以不处理，交给jvm处理(中断处理)
异常处理5个关键字try,catch,finally,throw,throws

常见异常：

//RuntimeException或者他的子类(运行期异常，可以不用处理，默认交给jvm处理)
1、ArrayIndexOutOfBoundsException—>数组索引越界异常——>R
2、NullPointerException—>空指针异常———->R
3、FileNotFoundException—>找不到指定文件
4、IOException—>
5、ClassCastException—>类型转换异常——->R
6、ClassNotFoundException

throw关键字

作用：可以使用throw关键字在指定的方法中抛出异常
使用格式：throw new xxxException(“异常产生的原因”)
注意：
1.throw关键字必须写在方法内部
2.throw后面new的对象必须时Exception类或其子类对象，如果抛出的是RuntimeException或者他的子类(运行期异常，可以不用处理，默认交给jvm处理)，但如果是编译异常(写代码报错)，就必须处理这个异常，要么throws，要么try-catch

方法Objects.requireNonNull(arr,”传递参数值为null”);//当一个对象为空时抛出一个异常

throws关键字(声明异常)—>吧异常交给别人处理

抛给方法的调用者处理,当声明的多个异常有父子关系是时，只声明父异常就行

try…catch捕获异常

如果try中产生了异常，就转到catch处理异常，处理完之后继续执行try…catch之后的代码。如果try没有产生异常，就不会执行catch。

子类父类异常关系(父类什么样子类就什么样)

子类重写父类方法时，如果父类方法抛出异常，那么子类重写时也跟着抛出异常就行了。如果父类方法没有抛出异常，那么子类重写时也不能抛出异常，只能在方法内部捕获。

finally代码块

不管是否发生异常都要执行

自定义异常类

格式 public class xxxException extends Exception(RunTimeException)
继承Exception：就是一个编译期异常，必须处理(throws or try…catch)
继承RunTimeException：就是一个运行期异常，可以不处理，交给jvm处理

自定义异常类练习

多线程

创建线程的三种方法

1.继承Thread类，2.实现Runnable接口，3，实现Callable接口和Future接口
1、Thread例

2、Runnable

并发与并行

并行：同时执行
并发：在一段时间内同时执行

匿名内部类实现多线程

线程同步解决安全问题

1、同步代码块(synchronized)
synchronized(同步锁){需要同步操作的代码}
下图为错误写法

分析为什么卖出了0和-1张票

正确写法

思考为什么synchronized不包括while循环？

思考为什么加上sleep语句后更容易出现三者同步卖票的现象？

生产者和消费者问题

_

线程池

Lambda

使用lambda前提，接口中有且只有一个抽象方法
注意：()里面的数据类型可以省略
（）里面只有一个参数，可以省略括号
{}里面如果之哟有一条语句，则{}和return，分号都必须一起省略

File and IO

网络编程

命令ipconfig —>查看本机IP地址
常用的端口号
1、80 网络端口 如www.baidu.com:80就可 www.baidu.com:70就不行
2、数据库 mysql：3306 oracle：1521
3、Tomcat服务器：8080

TCP通信：面向连接的通信，客户端和服务器端必须经过三次握手，建立逻辑链接。
套接字

客户

服务器

文件上传案列

文件上传案列服务器端优化

模拟B/S服务器

函数式接口

只有一个抽象方法。可以有其他的默认、静态私有方法。但是不能有其他的抽象方法。
@FunctionalInterface—>注解
函数式接口的作用：方法的参数或者返回值

常用的函数式接口

Supplier接口 里面有一个 E get()方法.

Consumer 接口，抽象方法void accpet(E t).

Junit单元测试—>白盒测试

1.黑盒测试：不需要写代码，给输入值，看程序是否能输出期望的值
2.白盒测试：要写代码，关注程序的具体执行流程
@Test注解

注解—>说明程序

作用分类
1.编写文档 生成javadoc文档
2.代码分析 使用反射
3.编译检查 Override

内置的注解

Java 定义了一套注解，共有 7 个，3 个在 java.lang 中，剩下 4 个在 java.lang.annotation 中。
作用在代码的注解是

• @Override - 检查该方法是否是重写方法。如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。
• @Deprecated - 标记过时方法。如果使用该方法，会报编译警告。
• @SuppressWarnings - 指示编译器去忽略注解中声明的警告。SuppressWarnings(“all”)—>压制所有警告

@Before会在测试方法前被执行
@After会在测试方法结束后被自动执行
不管发布发生异常都会执行上面两个

反射：将类的各个组成部分封装为其他对象，就是反射机制

获取Class对象的三种方式
1、处于源代码阶段：Class.forName(“全类名”)将字节码文件加载进入内存，返回Class对象。
多用于配置文件，将类名定义在配置文件中，读取文件加载类
2、处于Class对象阶段：类名.class
多用于参数传递
3、有了对象阶段：通过 对象.getClass()方法获取
多用于对象获取字节码方式
*同一个字节码文件在一次程序运行过程中，只会被加载一次，不论通过哪一个方式获取的Class对象都是同一个

Class功能
1、获取成员变量们
*获取所有public修饰的成员变量

*获取指定名称的public修饰的成员变量

*

*

2、获取构造方法们
*

*

*

*

3、获取成员方法们
*

*

*

*Method getDeclaredMethod(String name, Class<?>… parameterTypes)
4、获取类名

Field(成员变量)的方法

_忽略修饰符的安全检查_setAccessible(true)—>暴力反射

Constructor(构造方法)的方法

如果使用空参方法构造可以使用Class对象的newInstance方法

Method成员方法

获得方法名称

Person
private String name;
private int age;
public String a;
protected int b;
int c;
private int d;

public Person() {
}

public Person(String name, int age) {
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
public void wx(){
System.out.println(“wx”);
}
public void wx(String name){
System.out.println(name);
}
private void mch(String name){
System.out.println(name+”mch”);
}
@Override
public String toString() {
return “Person{“ +
“name=’” + name + ‘\’’ +
“, age=” + age +
“, a=’” + a + ‘\’’ +
“, b=” + b +
“, c=” + c +
“, d=” + d +
‘}’;

ReflectField


ReflectConstructor
**

ReflectMethod
、
案列
写一个框架，不能改变该类的任何代码前提下，可以帮我们创建任意对象，并且执行其中任意方法
实现
配置文件**
*反射**
步骤
**1.将需要创建对象的全类名和需要执行的方法定义在配置文件中
**2.在程序中加载读取配置文件
**3.使用反射技术来加载类文件进内存
**4.创建对象
**5.执行方法
ReflectKuangJia