java文件先通过javac Hello.java编译成字节码文件，会生成一个class文件
然后再java Hello （注意不用加class ，java 本身就是编译class）
psvm publicstatic void main
sout System.out.println
ctrl+D复制当前行到下一行
100.for for (int i = 0; i < 100; i++) { }
alt+ins 生成构造器
ctrl + alt + t 快速生成捕获异常
变量：可以变化的量
数据类型 + 变量名 = 值
String a = “15”; a就叫变量
所有变量必须先定义后使用0
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N57i0if5-1601693619273)(C:\Users\13778\Desktop\图片\1.png)]
局部变量：在方法里定义，生命周期就在一个大括号里
public static void main(String[] args) { //局部变量：必须声明和初始化值 int i = 10; System.out.println(i); }实例变量：类和方法之间定义 从属于对象 ，如果不进行初始化，基本类型默认值为0
public class Demo04 { //实例变量:从属于对象 如果不进行初始化，默认值为0 // 除了基本类型，其余默认值为null // 布尔值默认是false String name; int age; public static void main(String[] args) { Demo04 st1 = new Demo04(); System.out.println(st1.name); System.out.println(st1.age); // st1.name="董泽超"; //st1.age=18; }类变量：在类和方法之间用static定义 可以直接调用
public class Demo04 { //类变量 static static double salary = 2500; public static void main(String[] args) { System.out.println(salary); }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eeAW6gge-1601693619274)(C:\Users\13778\Desktop\图片\2.png)]
常量：初始化之后就不能变动
final 常量名 = 值
数据类型分为基本类型和引用类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C8HQXN6P-1601693619276)(C:\Users\13778\Desktop\图片\3.png)]
引用类型：类 接口 数组
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rXVWVFQo-1601693619277)(C:\Users\13778\Desktop\图片\4.png)]
强制转换 （类型）变量名 高–低 自动转换 低–高
public class Demo02 { public static void main(String[] args) { //不同数据类型的数据先转化为同一类型，再运算 int i = 128; byte b = (byte)i;//内存溢出 double d = i; //强制转换 （类型）变量名 高容量--低容量 //自动转换 低--高 System.out.println(i); System.out.println(b); /* 1.不能对布尔值进行转换 2.不能把对象类型转换为不相干的类型 3.在把高容量转换成低容量时，强制转换 4.转换时候可能存在内存溢出，或者精度问题 */ System.out.println((int)23.7);//23 System.out.println((int)-45.5f);//-45 char c = 'a'; int c1 = c+1; System.out.println(c1); System.out.println((char)c1); //操作较大的数时，注意溢出问题 int money = 1000000000; int years = 20; int total = money*years; long total2 = money*years; System.out.println(total);//-1474836480 计算溢出 System.out.println(total2);//默认是int 转换前就存在问题了 long total3 = money*(long)years;//先把一个数转换成long System.out.println(total3); } }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rvyYXtAj-1601693619278)(C:\Users\13778\Desktop\图片\5.png)]
运算有数为long时，结果为long，有double时，结果为double
其他结果为int
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iCIxbki9-1601693619279)(C:\Users\13778\Desktop\图片\6.png)]
关系运算符的结果：正确或者错误 布尔值
与：一假则假
或：一真则真
非：真变假，假变真
//与（and） 或（or） 非（取反） boolean a = true; boolean b = false; System.out.println("a && b"+(a && b));//与：一假则假 System.out.println("a || b"+(a || b));//或：一真则真 System.out.println("!(a && b)"+(!(a && b)));//非：真变假，假变真a++ 先将a赋值给b，再+1
++a 先+1，再赋值给c
//++ -- 自增自减 一元运算符 int a = 3; int b = a++; //a++ 先将a赋值给b，再+1 System.out.println(a); int c = ++a;//++a 先+1，再赋值给c System.out.println(a); System.out.println(b); System.out.println(c);结果为 4 5 3 5
与运算，先判断前面的条件，如果为假，不运行后面的条件了
d为false c为5
2<<3 结果为16
int a = 10; int b = 20; //字符串连接符 + , String System.out.println(""+a+b); //1020 System.out.println(a+b+""); //30 //字符串在前面才不会加在一起 //三元运算符 //x?y:z 如果x==true,则结果为y，否则为z int score = 80; String type = score<60?"不及格":"及格"; 输出及格break用于强行退出循环
continue用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下次是否执行循环的判定
修饰符 返回值类型 方法名 （参数类型 参数名称）{
方法体
return 返回值；
}
形参 方法定义时的参数
实参 实际调用传递的参数
返回值类型为void就不用return了
//非静态方法 public void say(){ System.out.println("hello"); } //静态方法 可以直接调用 public static void said(){ System.out.println("word"); }方法名一样， 参数类型不同
编译class文件后要退到src目录
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qgJiLLdF-1601693619280)(C:\Users\13778\Desktop\图片\image-20200821101553404.png)]
可以赋予多个值，只能位于形参尾
声明数组是放入栈中，创建数组是放入堆中
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lX2NvDuI-1601693619281)(C:\Users\13778\Desktop\图片\image-20200825164728689.png)]
ArrayIndexOutOfBoundsException 数组下标越界异常
int[] a = {1,2,3,85,2,14,478,3}; Arrays.sort(a);//数组排序 System.out.println(Arrays.toString(a));//输出数组以类的方式组织代码，以对象的组织（封装）数据
//类实例化之后才存在 public void a(){ b(); } //static 和类一起加载的 public static void b(){ } public class Student { public static void main(String[] args) { Student a = new Student(); a.say(); } //非静态方法 public void say(){ System.out.println("hello"); } //静态方法 可以直接调用 public static void said(){ System.out.println("word"); } }1.和类名相同
2.没有返回值
作用：
1.new 本质在调用构造方法
2.初始化对象的值
public class People { String name; //实例化初始值 //1.使用new，必须有构造器 //2.初始化值 public People() { this.name = "超"; } public People(String name) { this.name = name; } } ublic class Demo04 { public static void main(String[] args) { People a = new People("zc"); System.out.println(a.name); } }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZQO6G0Vk-1601693619282)(C:\Users\13778\Desktop\图片\image-20200901114052081.png)]
get 获取这个数据
set 给这个数据设置值
public class Student { private String name;//姓名 private int age; private char sex; //get 获取这个数据 //set 给这个数据设置值 public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { if (age > 120 || age < 0) { this.age = 3; } else { this.age = age; } } public char getSex() { return sex; } public void setSex(char sex) { this.sex = sex; } /* public static void main(String[] args) { Person a = new Person(); }} public class Demo01 { public static void main(String[] args) { Student chao = new Student(); chao.setName("超"); System.out.println(chao.getName()); chao.setAge(10); System.out.println(chao.getAge()); chao.setSex('男'); System.out.println(chao.getSex()); } }所有的类，都默认直接或者间接继承Object
子类继承了父类，就会拥有父类全部的方法
一个儿子只能与一个爸爸，一个爸爸能有多个儿子
private无法被继承
1.super调用父类的构造方法，必须在构造方法的第一行
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
对比this：
this：本身调用这个对象，没继承也能使用，本类的构造
super：代表父类对象的应用，只能在继承条件下才可以使用，父类的构造
需要有继承关系，子类重写父类的方法
1.方法名相同
2.参数列表相同
3.修饰符 范围可以扩大 public>Protected>Default>private
4.抛出异常范围可以被缩小，不能被扩大 ClassNotFoundException -->Exception(大)
为什么需要重写：
1.父类的功能，子类不一定需要，不一定满足
Alt+Insert :Override
public class B { public void test(){ System.out.println("B=>test"); } } public class A extends B { //Override重写 @Override//注解：有功能的注释 public void test() { System.out.println("A"); } } A a = new A(); a.test();//A B b = new A();//子类重写父类的方法 b.test();//A不能重写的：
1.static 方法属于类，不属于实例
2.final 常量
3.private 方法
1.多态是方法的多态，属性没有多态
2.父类和子类有联系 类型转换异常 ClassCastException
3.存在条件：继承关系，方法需要重写 父类引用指向子类 father f1 = new Son();
子类转换为父类，可能丢失自己本来的一些方法
1.父类引用指向子类的对象
2.把子类转换为父类，向上转换
3.把父类转换为子类，向下转换，强制转换
4.方便方法调用，减少重复的代码
作用：
1.约束
2.定义一些方法，让不同的的实现
3.默认方法都是public abstract
4.常量都是public static final
5.接口不能被实例化 接口中没有构造方法
6.implements可以实现多个接口
7.必须重写接口中的方法
//interface 定义关键字 接口都需要有实现类 public interface UserService { //常量public static final int age = 99; //接口中的所有定义的方法都是抽象的 默认都是public abstract void add(String name); void delete(String name); void update(String name); void query(String name); } public interface TimeService { void time(); } //implements 实现接口 //实现了接口的类，必须重写接口的方法 //利用接口实现多继承 public class UserServiceImpl implements UserService,TimeService{ @Override public void add(String name) { } @Override public void delete(String name) { } @Override public void update(String name) { } @Override public void query(String name) { } @Override public void time() { } }成员内部类
public class Outer { private int id = 10; public void out(){ System.out.println("这是外部类的方法"); } public class Inner{ public void in(){ System.out.println("这是内部类的方法"); } //获得外部类的私有属性 public void getID(){ System.out.println(id); } }}静态内部类
public class Outer { public void out(){ System.out.println("这是外部类的方法"); } public static class Inner{ public void in(){ System.out.println("这是内部类的方法"); } //获得外部类的私有属性 }}局部内部类
public class Outer { //局部内部类 public void method(){ class Inner{ public void in(){ } } } }匿名内部类
可以操作外部类的私有属性
ctrl + alt +t
public class Demo01 { public static void main(String[] args) { try { new Demo01().test(1,0); } catch (ArithmeticException e) { e.printStackTrace(); } finally { } } //throws 用于方法上 //throw 用于方法中 public void test(int a ,int b)throws ArithmeticException{ if(b==0){ throw new ArithmeticException(); } } } /* int a = 10; int b = 0; try { System.out.println(a/b); } catch (Exception e) { e.printStackTrace();//打印错误的栈信息 } finally { }*/ /* try{//try检测区域 System.out.println(a/b); }catch(ArithmeticException e ){//捕获异常 System.out.println("异常"); }finally {//处理善后工作 System.out.println("finally"); } //finally 可以不要 用于资源关闭 //假设要捕获多个异常，从小到大捕获 try{ new Demo01().a(); }catch(Error e){ System.out.println("Error"); }catch(Exception e){ System.out.println("Exception"); }catch(Throwable e ){//catch(想要捕获的异常类型) System.out.println("Throwable"); }finally{ System.out.println("finally"); } } public void a(){ b(); } public void b(){ a(); */cast 转换
salary 工资
param 参数
struct 结构
operator 符号
}catch(Exception e){ System.out.println("Exception"); }catch(Throwable e ){//catch(想要捕获的异常类型) System.out.println("Throwable"); }finally{ System.out.println("finally"); } } public void a(){ b(); } public void b(){ a(); */ ### 自定义异常 ```java //自定义异常类 public class Demo02 extends Exception{ //传递数字10 private int detail; public Demo02(int a ){ this.detail = a; } //toString 打印异常信息 @Override public String toString() { return "Demo02{" + detail + '}'; } } public class Test { //可能会存在异常的方法 static void test(int a) throws Demo02 { System.out.println("传递的参数为"+a); if(a>10){ throw new Demo02(a); } System.out.println("ok"); } public static void main(String[] args) { try { test(11); } catch (Demo02 e) { System.out.println("异常为"+e); } } }cast 转换
salary 工资
param 参数
struct 结构
operator 符号
array 数组
