强制转换
由高转低需要强制转化，低到高自动转换byte short chat int long float double
int i=128;
byte b=(byte)i;
1、不能把布尔类型转换2、不能把对象转换成不相干的类型3、转换的时候可能会出现内存溢出精度问题
int money=10_0000_0000;
int year=20;
int total=money*year;//结果溢出了int的范围
long total1=monry*((long)year);//先把一个数转化为long类型
变量
public class Demo{
//实例变量不自行初始化默认为0或者0.0 布尔值默认为false 除了基本类型其他都为null
String name;//实例变量，从属于对象
static double a=1200;//类变量，前边加个static
//main方法
public static void main(String[] args){
int i=10;//局部变量，其他方法中不能使用，只在该{}有用
//变量类型 变量名字
Demo demo1=new Demo();
System.out.println(demo1.name);//输出实例变量
System.out.println(a);//使用类变量
}
//其他方法
public void add(){
}
}
常量
static final float PI=3.14 //使用final定义常量，固定值，之后可以直接引用
运算符
int a=3; int a=3;
int b=a++; //相当于 int b=a;
int a=a+1;
int a=1; int a=1;
int b=++a; //相当于 int a=a+1;
int b=a;
连接符
int a=1;
int b=2;
System.out.println(""+a+b)//结果为12
System.out.println(a+b+"")//结果为3
三元运算符
x ? y : z 如果x为真则返回y，如果为假，则返回z
文档注释
//使用/**加回车进行文档注释
/**
* @author tao 作者名
* @version 1.0 版本号
* @since 1.8 指明需要最早使用的jdk版本
*/
public class Doc {
String name;
/**
*
* @param name 参数名
* @return 返回值情况
* @throws Exception 抛出异常
*/
public String test(String name) throws Exception{
return name;
}
}
用户交互Scanner
通过Scanner类来获取用户的输入
语法：Scanner s=new Scanner (System.in);
next():
1、一定要读取到有效字符后才结束输入
2、对输入有效字符之前遇到的空白，next方法会自动将其去掉
3、只有输入有效字符后才将其后面输入的空白作为分隔符或结束符
4、next（）不能得到带有空格的字符串
nextLine()：
1、以Enter为结束符，可以获得空白
switch
每个case语句中都需要一个break,不然就会输出下面全部的case值
支持使用字符串对比
print和println的区别
print输出不会换行 println输出会换行
break和continue
break用于强行跳出循环，不执行循环语句剩余的语句
continue用户终止某次循环，跳过本次循环继续执行下一次循环的判断
方法
1、方法包含一个方法头和一个方法体
修饰符 返回值类型 方法名（参数类型 参数名）{
方法体
return 返回值；
}
形式参数：用于来定义方法内的参数
实际参数：实际调用给它的参数
方法的重载
1、名字一摸一样但是参数不同(可以个数不同、类型不同、参数排列顺序不同)
2、方法的返回类型可以相同也可以不同
3、只有返回类型不同不是方法的重载
可变参数
在方法声明中在指定参数类型后加一个省略号
一个方法中只能指定一个可变参数，必须是方法的最后一个参数，任何普通的参数必须在它之前声明
递归
边界条件 前阶段 返回阶段n*n-1
数组
必须声明数组变量
int[] num;
使用new操作符来创建数组
int[] num=new int[10];
获取数组长度
num.length
数组的四个特点：
①、其长度是确定的。数组一旦被创建，它的大小就是不可以改变的
②、元素必须是相同的类型，不允许出现混合类型
③、数组中的元素可以是任何数据类型，包括基本类型和引用类型
④、数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，java中对象是在堆中的，因此无论保存原始类型还是其他对象类型。数组本身是在堆中的。(new出来的都是在堆)
数组的边界
下标的合法区间：[0，length-1]
ArrayIndexOutOfBoundsException：数组下标越界异常
##
增强的数组循环
int[] arrays={1,2,3,4}
//适合打印输出,没有下标
for(int array:arrays){
System.out.printl(array);
}
java内存分析
java内存分为堆、栈、和方法区
①、堆：存放new的对象和数组；可以被所有的线程共享，不会存放别的对象引用
②、栈：存放基本变量类型（包含这个基本类型的具体数值）；引用对象的变量（会存放这个在堆里面的具体地址）
③、方法区：可以被所有线程共享；包含了所有的calss和static变量
Arrays类
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用
具有以下功能：
1、给数组赋值：使用.fill方法
2、对数组排序：通过sort方法，升序排序
3、比较数组：通过equals方法比较数组中元素是否相等
4、查找数组元素：通过binarySearch方法对排序号的数组进行二分查找
冒泡排序
比较数组中两个相邻的元素如果第一个比第二个数大，交换他们的位置，每次比较都会产生一个最大一个最小，下一轮则少一次排序
每一轮都能产生一个最大或者最小的数放在最后面或者最前面，然后继续从第一个开始比较
面向对象OOP
思想：分类得思维，思考问题首先会解决问题需要那些分类，然后对这些分类进行单独思考。
使用new关键字创建得时候，除了分配内存空间外，还会给创建好得对象进行默认得初始化以及对类中构造器得调用
本质：以类得方式组织代码，以对象得方式封装数据
三大特性
封装：
程序设计要求”高内聚，低耦合“内聚指类的内部数据操作细节自己完成，不允许外部干涉，耦合是指暴露少量方法给外部使用
（数据的隐藏）禁止直接访问一个对象中数据的实际标识，而应该通过操作接口来访问属性私有(private)，get/set
1、提高程序的安全性，保护数据
2、隐藏代码的实现细节
3、统一接口
4、系统可维护性增加
继承：
本质是对类的抽象，extend意思为子类是父类的扩展，在JAVA中只有单继承没有多继承（一个爸爸可有多个儿子）
继承是类和类之间的一种关系。继承关系的两个类一个为子类一个为父类，子类使用extend标识继承父类
所有的类都默认继承object类
多态：
同一方法可以根据发送对象不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
存在条件：①、有继承关系
②、子类重写父类方法
③、父类引用指向子类对象
注意事项： 1、多态是方法的多态，属性没有多态
2、父类和子类有联系（存在父子关系）不可以将一个类型转化为另一个类型（ClassCastException）
3、存在条件：继承关系，方法需要重写，父类引用指向子类对象Father f1=new Son()
不能重写(无多态) ①、static方法属于类不属于实例，不能被重写
②、final常量不能被重写
③、private方法不能被重写
对象，是具体得事物，类，是抽象得，是对对象得抽象
构造方法
类中的构造器（构造方法）实在进行创建对象时候必须要调用得
①、构造方法和类的名字相同
②、必须没有返回类型也不能写void
作用：
①、new本质在调用构造方法
②、初始化对象的值
注意点：
使用new本质是在调用构造方法，定义有参一定要显示无参构造，super调用父类的构造方法必须在子类构造方法第一行
alt+insert自动将有参无参构造方法补齐
super和this
super注意点
①、super调用父类的构造方法，必须在构造方法的第一个
②、super必须只能出现在子类的方法或者构造方法中
③、super和this不能同时调用构造方法（因为都必须保证他们在第一行）
与this对比
①、代表的对象不同
this:本身调用者这个对象
super:代表父类对象
②、前提：
this:没有继承也可以使用
super：只能在继承条件才可以使用
③、构造方法
this():该类的构造
super():父类的构造
方法的重写
需要有继承关系
子类重写父类的方法，方法一致但是方法体不同
①、方法名必须相同
②、参数列表必须相同
③、修饰符：范围可以扩大，父类private子类可以编程public(反过来不行)
④、抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException(小)–>Exception(大)
为什么需要重写：父类的功能，子类不一定需要或者不一定满足
instanceof
根据父子类关系判断是否属于父子
先判断是否是继承关系，不是的话直接报错，是的话继续判断是否为父子
类的大小顺序：
Object>String
Object>Person>teacher
Object>Person>student
类型强制转化
//例如父类Person要使用Student子类独有的方法go()
高 -------------->低
Person person=new Student();
//这里不能使用person.go();因为go为子类独有的方法
//类型强制转化
((Student) person).go();
//子类转化为父类,可能丢失自己的本来的一些方法（大空间赋值给小空间，子类大空间中独有的方法会丢失）
Student student=new Student();
student.go();
低------------->高
Person person=student;//父类的引用指向子类的对象
①、父类的引用指向子类的对象
②、子类转换为父类（向上转型），不用强制转化，丢失子类独有方法
③、父类转化为子类（向下转型），需要强制转化
④、方便方法的调用，较少重复的代码
static
静态属性可以直接使用类名调用,静态就是属于该类，随着类加载就存在，static方法只执行一次，后面不执行
Public class Student{
private static int age;
private String name;
public void run(){
//非静态可以直接调用静态，静态不能直接调用非静态
go();
}
public static void go(){
}
public static void main(String[] args){
Student s1=new Student();
System.out.println(Student.age);
System.out.println(s1.age);
s1.run();
Student.go;//或者直接go();因为再类里面
}
}
public class Person{
static{
System.out.println("静态代码")
}
{
System.out.println("匿名代码")
}
public Person(){
System.out.println("构造方法")
}
public static void main(String[] args){
Person s1=new Person();//输出顺序：①、静态代码②、匿名代码③、构造方法
Person s2=new Person();//只输出：②、匿名代码③、构造方法
}
}
抽象类
子类必须重写这个父类抽象类的所有抽象方法，不然会报错，抽象类的所有抽象方法都必须由继承它的子类实现，除非子类也是抽象类 则由子子类实现。（抽象类相当于房子的图纸，设计好了让子类去实现）
注意点：
①、不能new这个抽象类，只能靠子类去实现它，只能去new他的一些子类对象
②、抽象类中可以有普通方法，抽象方法必须在抽象类中：约束作用
接口interface
接口就是规范，定义的是一组规则，体现现实中你是车，就必须能跑类似的规则
接口的本质是契约，就像法律，制定好后必须遵守
对比
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有，使用abstract定义，利用extends继承
接口：只有规范，自己无法写方法，使用interface定义，使用implement继承
⭐注意点：
①、接口中定义的所有方法都需要被子类重写实现，定义一些方法让不同的人去实现
②、接口中的所有方法定义其实都是抽象的public abstract
③、接口里面定义的属性都是常量public static final
④、接口不能被实例化，接口中没有构造方法
⑤、implement可以实现多个接口
异常机制
异常指程序运行中出现的不期而至的各种状况：文件找不到、网络链接失败、非法参数等。
java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类
分类
①、检查性异常：最具代表性的检查性异常是用户错误或问题引起的异常，程序员无法预见的
②、运行时异常：运行时异常时可能被程序员避免的异常。以检查性异常相反，运行时异常可以在编译时被忽略
③、错误ERROR：错误不是异常，而是脱离程序员控制的问题，错误在代码中通常被忽略
ERROR
ERROR类对象由java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
java虚拟机运行错误，当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。异常发生时JVM一般会选择线程终止
还有发生再虚拟机试图执行应用时，如：类定义错误、链接错误。这些错误时不可查的，因为他们再应用程序控制和处理能力之外不允许出现的错误。
Exception
Exception中有一个重要子类RuntimeException（运行时异常）
ArrayIndexOutOfBoundsException（数组下标越界）
NullPointerException（空指针异常）
ArithmeticException（算术异常）
MissingResourceException（丢失资源）
ClassNotFoundException（找不到类）
异常处理机制
抛出异常 捕获异常
异常处理关键字：try catch finally throw throws
自定义异常
使用Java内置的异常类可以描述再编程时出现的大部分异常情况，用户可以自定义异常，只需要继承Exception类即可
步骤：①、创建自定义异常类
②、再方法中通过throw关键字抛出异常
③、如果在当前抛出异常的方法中处理异常，可使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛 出给方法调用者的异常。
④、在出现异常方法的调用者中捕获并处理异常
原创文章，作者：506227337，如若转载，请注明出处：https://blog.ytso.com/278164.html