类型强制转换
// byte、short、char 运算时直接提升为 int
int i = (int)1.5; // double类型数据强制转成int类型，直接去掉小数点。
long up = Long.parseLong(lines[lines.length-3]); // string转为long
Float.parseFloat(lines[0]); // string转float
三元运算符
数据类型 变量名 = 布尔类型表达式？结果1：结果2
1==2 ? 100 : 200
判断语句
if 语句
if(关系表达式)｛ 语句体; ｝
if-->else 语句
if(关系表达式) { 语句体1; }else { 语句体2; }
if-->else if-->else语句
if (判断条件1) { 执行语句1; } else if (判断条件2) { 执行语句2; }else if (判断条件n) { 执行语句n; } else { 执行语句n+1; }
switch语句
switch(表达式) { case 常量值1: 语句体1; break; case 常量值2: 语句体2; break; ... default: 语句体n+1; break; }
for循环语句
for(初始化表达式①; 布尔表达式②; 步进表达式④){ 循环体③ }
for(int x = 0; x < 10; x++) { System.out.println("HelloWorld"+x); }
for(元素的数据类型 变量 : Collection集合or数组){ //写操作代码 } // 增强for
while循环语句
while(布尔表达式②){ 循环体③ 步进表达式④ }
while(i<=10){ System.out.println("HelloWorld"); //步进 i++; }
do...while循环语句
do{ 循环体③ 步进表达式④ }while(布尔表达式②);
do {System.out.println("HelloWorld"); x++; }while(x<=10);
跳出循环语句
break // 终止switch或者循环
continue // 结束本次循环，继续下一次的循环
死循环
死循环的是永不结束的循环
嵌套循环
for(初始化表达式①; 循环条件②; 步进表达式⑦) { for(初始化表达式③; 循环条件④; 步进表达式⑥) { 执行语句⑤; } }
for(int i = 0; i < 5; i++){ for(int j = 0; j < 8; j++){ System.out.print("*"); } System.out.println(); }
Stream流
String[] array = {"张无忌", "周芷若", "赵敏", "张强", "张三丰"};
Stream<String> original = Stream.of(array);
original.filter(s ‐> s.startsWith("张")) // 过滤 创建一个新的 stream流 原来的关闭
original.filter(s ‐> s.length() == 3)
original.forEach(System.out::println); // 逐一处理
result = original.map(str‐>Integer.parseInt(str)); // 映射 将流中的元素映射到另一个流中
System.out.println(result.count()); // 统计 元素个数
Stream<String> result = original.limit(2); // 取用前几个
Stream<String> result = original.skip(2); // 跳过前几个
Stream<String> streamA = Stream.of("张无忌");
Stream<String> streamB = Stream.of("张翠山");
Stream<String> result = Stream.concat(streamA, streamB); // 组合：concat 合并两个流为一个
数组:
容器
是将多个数据存储到一起，每个数据称为该容器的元素。
数组概念
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
格式1
数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度]
int[] arr = new int[3];
格式2
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...}
int[] arr = new int[]{1,2,3,4,5};
格式3
数据类型[] 数组名 = {元素1,元素2,元素3...};
int[] arr = {1,2,3,4,5};
数组的访问
数组名[索引]
int[] arr = new int[]{1,2,3,4,5};
arr[0] = 1; // 访问数组
数组遍历
for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); }
数组方法
arr.length // 打印数组长度
面向对象:
类和对象
类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该 类事物
属性：就是该事物的状态信息。
行为：就是该事物能够做什么。
对象：是一类事物的具体体现。对象是类的一个实例,必然具备该类事物的属性和行为
类的定义格式
public class ClassName { //成员变量 //成员方法 }
定义类：就是定义类的成员，包括成员变量和成员方法。
成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
成员方法：和以前定义方法几乎是一样的。只不过把static去掉
创建对象
类名 对象名 = new 类名();
使用对象访问类中的成员:
对象名.成员变量；
对象名.成员方法()；
成员变量的默认值
整数（byte，short，int，long） 0
浮点数（float，double） 0.0
字符（char） 'u0000'
布尔（boolean） false
数组，类，接口 null
成员变量和局部变量区别
成员变量：类中，方法外
局部变量：方法中或者方法声明上(形式参数)
成员变量：类中
局部变量：方法中
成员变量：有默认值
局部变量：没有默认值。必须先定义，赋值，最后使用
成员变量：堆内存
局部变量：栈内存
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
封装
概述
防止类的代码和数据被其他类随意访问,要访问该类的数据,必须通过指定的方式
private
private是一个权限修饰符，代表最小权限。
可以修饰成员变量和成员方法。
被private修饰后的成员变量和成员方法，只在本类中才能访问。
private的使用格式
private 数据类型 变量名;
private String name;
提供 getXxx 方法 / setXxx 方法，可以访问成员变量
public void setName(String n) { name = n; }
public String getName() { return name; }
this关键字
this代表所在类的当前对象的引用
this使用格式
this.成员变量名；
public void setName(String name) { this.name = name; }
构造方法
修饰符 构造方法名(参数列表){ // 方法体 }
public class Student { private String name; private int age;
// 无参数构造方法
public Student() {}
// 有参数构造方法
public Student(String name,int age) {
this.name = name;
this.age = age; } }
如果你不提供构造方法，系统会给出无参数构造方法。
如果你提供了构造方法，系统将不再提供无参数构造方法。
构造方法是可以重载的，既可以定义参数，也可以不定义参数。
对象被创建的时候,构造方法将会被执行
Scanner
创建对象
数据类型 变量名 = new 数据类型(参数列表);
Scanner sc = new Scanner(System.in);
调用方法
变量名.方法名();
String i = sc.next(); // 接收一个键盘录入的数据
int i = sc.nextInt(); // 接收一个键盘录入的整数
Object类
在对象实例 化的时候，最终找的父类就是Object。
如果一个类没有特别指定父类， 那么默认则继承自Object类
toString方法
返回该对象的字符串表示。
toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
equals方法
指示其他某个对象是否与此对象“相等”。
调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的
String
特点
字符串不变：字符串的值在创建后不能被更改
因为String对象是不可变的，所以它们可以被共享
"abc" 等效于 char[] data={ 'a' , 'b' , 'c' }
String str = new String(); // 无参构造
String str2 = new String(char chars[] = {'a', 'b', 'c'}); // 通过字符数组构造
String str3 = new String(byte bytes[] = { 97, 98, 99 };); // 通过字节数组构造
常用方法
s1.equals(s2); // 比较字符串的内容是否相同 区分大小写
s1.equalsIgnoreCase(s2); // 比较字符串的内容是否相同,忽略大小写
s.length(); // :获取字符串的长度，其实也就是字符个数
s.concat("**hello itheima"); // 将将指定的字符串连接到该字符串的末尾.
s.charAt(0); // 获取指定索引处的字符
s.indexOf("l"); // 获取str在字符串对象中第一次出现的索引,没有返回‐1
s.substring(0); // 从start开始截取字符串到字符串结尾
s.substring(3, 8); // 从start到end截取字符串。含start，不含end。
s.toCharArray(); // 把字符串转换为字符数组
s.getBytes(); // 把字符串转换为字节数组
String replace = str.replace("it", "IT"); // 替换字母it为大写IT
s.split("|"); // 创建字符串对象
static
概述
可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的
类变量
类变量：使用 static关键字修饰的成员变量。
static 数据类型 变量名; // 定义格式
static int numberID;
静态方法
类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。
修饰符 static 返回值类型 方法名 (参数列表){ // 执行语句 }
public static void showNum() { System.out.println("num:" + numberOfStudent); }
静态方法调用的注意事项
静态方法可以直接访问类变量和静态方法。
静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
静态方法中，不能使用this关键字。
调用格式
被static修饰的成员可以并且建议通过类名直接访问
类名.类变量名; // 访问类变量
类名.静态方法名(参数); // 调用静态方法
static 修饰的内容特点;
是随着类的加载而加载的，且只加载一次
存储于一块固定的内存区域（静态区）,所以,可以直接被类名调用
它优先于对象存在，所以，可以被所有对象共享
静态代码块
静态代码块：定义在成员位置，使用static修饰的代码块{ }。
位置：类中方法外。
执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。 格式
static { // 执行语句 }
final
概述
final： 不可改变。可以用于修饰类、方法和变量。
类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写。
变量：被修饰的变量，不能被重新赋值。
修饰类
final class 类名 { }
修饰方法
修饰符 final 返回值类型 方法名(参数列表){ //方法体 }
修饰变量
final int a; // 声明变量，使用final修饰
继承
概述
继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。
好处
提高代码的复用性。
类与类之间产生了关系，是多态的前提。
继承的格式
通过 extends 关键字
class 子类 extends 父类 { ... }
成员变量
子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字,修饰 父类成员变量，类似于之前学过的 this 。
super.父类成员变量名
super.num; // 访问父类中的num
成员方法
如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。
方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效 果，也称为重写或者复写。声明不变，重新实现。
子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样
构造方法
构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的
构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构 造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用
super和this
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身
super ：代表父类的存储空间标识(可以理解为父亲的引用)。
this ：代表当前对象的引用(谁调用就代表谁)
this.成员变量 ‐‐ 本类的
super.成员变量 ‐‐ 父类的
this.成员方法名() ‐‐ 本类的
super.成员方法名() ‐‐ 父类的
继承的特点
Java只支持单继承，不支持多继承
Java支持多层继承(继承体系)。
子类和父类是一种相对的概念。
抽象类
概述
如果一个类包含抽象方法，那么该类必须是抽象类。
定义
抽象方法 ： 没有方法体的方法。
抽象类：包含抽象方法的类。
abstract使用格式
使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
修饰符 abstract 返回值类型 方法名 (参数列表); // 定义格式：
public abstract void run()；
抽象类
如果一个类包含抽象方法，那么该类必须是抽象类。
abstract class 类名字 { } // 定义格式：
public abstract class Animal { public abstract void run()； }
抽象的使用
继承抽象类的子类必须重写父类所有的抽象方法
注意事项
抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
抽象类中,可以有构造方法,是供子类创建对象时,初始化父类成员使用的。
抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类
抽象类的子类,必须重写抽象父类中所有的抽象方法,否则,编译无法通过而报错。除非该子类也是抽象类
接口
概述
接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么 接口的内部主要就是封装了方法
接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并 不是类，而是另外一种引用数据类型。
接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）
定义格式
public interface 接口名称 { // 抽象方法 // 默认方法 // 静态方法 // 私有方法 }
含有抽象方法
抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。
public interface InterFaceName { public abstract void method(); }
含有默认方法和静态方法
默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写
静态方法：使用 static 修饰，供接口直接调用
public interface InterFaceName {
public default void method() {
// 执行语句
}
public static void method2() {
// 执行语句
} }
含有私有方法和私有静态方法
私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。
public interface InterFaceName {
private void method() {
// 执行语句
} }
非抽象子类实现接口：
必须重写接口中所有抽象方法。
继承了接口的默认方法，即可以直接调用，也可以重写。
class 类名 implements 接口名 {
// 重写接口中抽象方法【必须】
// 重写接口中默认方法【可选】
}
抽象方法的使用
定义接口：
public interface LiveAble {
// 定义抽象方法
public abstract void eat();
public abstract void sleep();
}
定义实现类：
public class Animal implements LiveAble {
@Override
public void eat() {
System.out.println("吃东西"); }
@Override
public void sleep() {
System.out.println("晚上睡");
} }
默认方法的使用
可以继承，可以重写，二选一，但是只能通过实现类的对象来调用
静态方法的使用
静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用
私有方法的使用
私有方法：只有默认方法可以调用。
私有静态方法：默认方法和静态方法可以调用。
接口的多实现
class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
// 重写接口中抽象方法【必须】
// // 重写接口中默认方法【不重名时可选】
}
抽象方法
接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次
默认方法
接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次
静态方法
接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。
优先级的问题
当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执 行父类的成员方法
接口的多继承
一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继 承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次
interface D extends A,B{
@Override
public default void method() {
System.out.println("DDDDDDDDDDDDDD");
}
}
成员特点
接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰
接口中，没有构造方法，不能创建对象。
接口中，没有静态代码块。
多态
概述
多态： 是指同一行为，具有多个不同表现形式。
多态体现的格式
父类类型 变量名 = new 子类对象;
变量名.方法名();
向上转型
向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的
父类类型 变量名 = new 子类类型(); // 就是多态
Animal a = new Cat();
向下转型
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的
子类类型 变量名 = (子类类型) 父类变量名;
Cat c =(Cat) a;
权限修饰符
public：公共的
protected：受保护的
default：默认的
private：私有的
不加权限修饰符，其访问能力与default修饰符相同
不同权限的访问能力
public protected default private
同一类中 √ √ √ √
同一包中(子类与无关类) √ √ √
不同包的子类 √ √
不同包中的无关类 √
内部类
概述
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
成员内部类
成员内部类 ：定义在类中方法外的类
定义格式：
class 外部类 { class 内部类{ } }
class Car { //外部类 class Engine { //内部类 } }
访问特点
内部类可以直接访问外部类的成员，包括私有成员
外部类要访问内部类的成员，必须要建立内部类的对象。
创建内部类对象格式
外部类名.内部类名 对象名 = new 外部类型().new 内部类型()
匿名内部类
匿名内部类 ：是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。
匿名内部类必须继承一个父类或者实现一个父接口。
包装类
装箱与拆箱
装箱：从基本类型转换为对应的包装类对象
Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法
拆箱：从包装类对象转换为对应的基本类型。
int num = i.intValue();
基本类型转换为String
基本类型直接与""相连接即可
String转换成对应的基本类型
public static byte parseByte(String s); // 将字符串参数转换为对应的byte基本类型。
public static short parseShort(String s); // 将字符串参数转换为对应的short基本类型。
public static int parseInt(String s); // 将字符串参数转换为对应的int基本类型
public static long parseLong(String s); // 将字符串参数转换为对应的long基本类型
public static float parseFloat(String s); // 将字符串参数转换为对应的float基本类型
public static double parseDouble(String s); // 将字符串参数转换为对应的double基本类型
public static boolean parseBoolean(String s); // 将字符串参数转换为对应的boolean基本类型
int num = Integer.parseInt("100");
函数式接口
概念
有且仅有一个抽象方法的接口。
格式
public interface MyFunctionalInterface { void myMethod(); } // 由于接口当中抽象方法的 public abstract 是可以省略的
@FunctionalInterface注解
编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错
泛型
泛型：可以在类或方法中预支地使用未知的类型。
定义格式：
修饰符 class 类名<代表泛型的变量> { }
ArrayList<Integer> list = new ArrayList<Integer>();
含有泛型的方法
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }
public <MVP> void show(MVP mvp) { System.out.println(mvp.getClass()); }
含有泛型的接口
修饰符 interface接口名<代表泛型的变量> { }
泛型通配符
泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。
类型名称 <? extends 类 > 对象名称 泛型的上限
public static void getElement1(Collection<? extends Number> coll){} // 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
类型名称 <? super 类 > 对象名称 // 泛型的下限
public static void getElement2(Collection<? super Number> coll){} // 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类