打印九九乘法表：
for(int a=1;a<10;a++){
for(int b=1;b<=a;b++){
System.out.print(a+"*"+b+"="+a*b+" "+"\t");
}
System.out.println();
}break:加在循环语句末尾，break以后的循环体中的语句不会继续执行,循环体外的会执行
如果是嵌套for循环,在内层循环遇到了break,只会跳出当前这一层内循环
for(int a=1;a<10;a++){
for(int b=1;b<=a;b++){
if(b==3)break;
System.out.print(a+"*"+b+"="+a*b+" "+"\t");
}
System.out.println();
}
//输出结果
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6
4*1=4 4*2=8
5*1=5 5*2=10
6*1=6 6*2=12
7*1=7 7*2=14
8*1=8 8*2=16
9*1=9 9*2=18 continue：跳出本次循环进入下一次循环，后本轮循环体中的语句不会继续执行,但是会继续执行下轮循环,循环体外的也会执行
for(int a=1;a<10;a++){
for(int b=1;b<=a;b++){
if(b==3)continue;
System.out.print(a+"*"+b+"="+a*b+" "+"\t");
}
System.out.println();
}
//输出结果
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6
4*1=4 4*2=8 4*4=16
5*1=5 5*2=10 5*4=20 5*5=25
6*1=6 6*2=12 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
//没有3产生随机数api
int random = new Random().nextInt(100);//生成100以内随机数，[0，100）左闭右开
int random = new Random().nextInt(100)+a//生成[a,1000）范围内的随机数
使用循环时注意：
- for：知道循环次数
- while/do while：当循环次数不确定时
- while：先判断，不符合规则，不执行代码
- do while：代码最先被执行一次，再去判断，符合规则，再次执行代码
- 尽量不要使用嵌套for循环，因为嵌套for循化次数会呈爆炸式增长，严重降低运算效率
方法的重载
方法的重载是指在一个类中定义多个同名的方法,但是每个方法的参数列表不同,程序在调用方法时,可以通过传递给他们的不同个数和类型的参数来决定具体调用哪个方法.（与返回值无关）
重载体现了程序的灵活性
方法重写
方法重写的场景
当父类方法的功能不能满足子类使用时，子类可以重写父类来自己实现该方法的功能。 方法重写的注意事项
子类重写父类方法后，调用方法不在调用父类的方法，而是调用子类重写后的方法
子类重写父类方法时，使用的权限修饰符要大于等于父类方法的权限
Public > protected > 默认 > private
父类private修饰的方法不能被子类重写，即使子类有完全相同的方法也不属于重写,属于重新定义一个新方法
静态方法不构成重写，只构成隐藏
可以使用@Override注解来判断是否构成重写，不构成重写会报错
final
被final修饰的变量类型不会发生变化
final byte a=2;
final byte b=4;
byte c=a+b;
System.out.println(c);数组
动态初始化
int[] a = new int[5];
静态初始化
int[ ]?b = new int[ ]{1,2,3,4,5};
int[ ]c = {1,2,3,4,5};
数组一经创建长度就不可改变，
数组常见错误：
java.lang.ArrayIndexOutOfBoundsException//数组下标越界异常
数组常用工具：Arrays.toString：把数组里的数据变成字符串展示?
Arrays.sort(数组)：对数组进行排序//如果是字母的话按照ascii码表进行排序
Arrays.copyOf(旧的数组名，新的长度)：复制新数组
int[] a = Arrays.copyOf(from, 5);//from：旧数组 5：新数组长度
int[] b = Arrays.copyOfRange(from, 2, 5);//2：表示从第二个开始截取[2,5) 范围左闭右开冒泡排序??
int []c={1,0,8,9,5,1,5};
for(int i=0;i<c.length;i++){
for(int j=0;j<c.length-1&&j!=i;j++){
if(c[j]>c[i]){
int t =c[j];
c[j]=c[i];
c[i]=t;
}
}
}
System.out.println(Arrays.toString(c));权限修饰符范围
public>protect>默认>private
方法的传值
对于基本类型而言，传值传递的是实际值，对于引用类型而言，传值传递的是地址值，
public class Test {
public static void main(String[] args) {
int []a={1,2};
change(a);
System.out.println(a[0]);
}
public static void change(int[] a){
a[0]++;
System.out.println(a[0]);
}
}
/------------------------------/
//结果为
2
2
public static void main(String[] args) {
int a=2;
change(a);
System.out.println(a);
}
public static void change(int a){
System.out.println(a);
}
//结果为
3
2
方法运行时，先在栈中开辟main空间，输入i=5，再开辟chang空间将i赋值为5，
然后调用chang方法，i自增为6，栈内存运行完就释放，所以最后输出时i的值不变运算符优先顺序：
（）>!>算术运算符>关系>逻辑>赋值
^相同取反，不同为真
b^b=0
0^a=a
a^b^b=a
public static void main(String[] args) {
int a=5; int b=6;
a=a^b;
b=a^b;//b=a^b^b=a
a=a^b;//a=a^a^b=b
System.out.println(a+"/"+b);
}
//结果
6/5面向对象
是一种编程思想，相对于面向过程，我们可以由原来问题的执行者变为指挥者，进而把生活中很多复杂的问题变得简单化。
所谓的面向对象就是将我们的程序模块化，对象化，把具体事物的特性属性和通过这些属性来实现一些动作的具体方法放到一个类里面，这就是封装。
封装是我们所说的面相对象编程的特征之一。除此之外还有继承和多态。继承有点类似与我们生物学上的遗传，就是子类的一些特征是来源于父类的，面向对象里的继承也就是父类的相关的属性，可以被子类重复使用，子类不必再在自己的类里面重新定义一回，父类里有的我们只要拿过来用就好了。而对于自己类里面需要用到的新的属性和方法，子类就可以自己来扩展了。当然，会出现一些特殊情况，就是我们在有一些方法在父类已经定义好了，但是子类我们自己再用的时候，发现，其实，我们的虽然都是计算工资的，但是普通员工的工资计算方法跟经理的计算方法是不一样的，所以这个时候，我们就不能直接调用父类的这个计算工资的方法了。这个时候我们就需要用到面向对象的另一个特性，多态。
多态，我们要在子类里面把父类里面定义计算工资的方法在子类里面重新实现一遍。多态包含了重载和重写。重写很简单就是把子类从父亲类里继承下来的方法重新写一遍，这样，父类里相同的方法就被覆盖了，当然啦，你还是可以通过super.方法来调用父类的工资计算方法。而重载就是类里面相同方法名，不同形参的情况，可以是形参类型不同或者形参个数不同，或者形参顺序不同，但是不能使返回值类型不同。
对象和类的关系
对象的状态用来描述对象的基本特征。//成员变量
对象的行为用来描述对象的功能。//成员方法
对象的标识是指对象在内存中都有一个唯一的地址值用来和其他对象区分开来。//对象名
类是一类事物的抽象，对象是具体的实现
构造方法
主要用来实例化对象，可重载，默认存在无参，有含参直接覆盖。
构造代码块：用来提取构造代码共性，优先于构造方法加载
加载顺序：
父类静态代码块--子类静态代码块--父类构造代码块--子类构造代码块
静态代码块只执行一次
局部代码块用来控制变量作用范围，优先级和方法体一样，谁先调用谁先执行
this 调用构造方法时必须位于第一条语句
继承提高了代码的复用性，但增加了耦合性
重写的要求
两同两小一大
两同:方法名 参数列表 要完全一致
两小:
子类返回值类型小于等于父类的返回值类型(注意此处说的是继承关系,不是值大小)
子类抛出异常小于等于父类方法抛出异常
一大:子类方法的修饰符权限要大于等于父类被重写方法的修饰符权限
重写与返回值类型无关
编译时多态：方法的重载；运行时多态：方法的重写，向上造型
向上造型：父类声明指向子类对象，能干什么看父类，具体执行看子类
package basic;
public class Test {
public static void main(String[] args) {
A a=new B();
a.AA();
}
}
class A{
public void AA(){
System.out.println(1);
}
}
class B extends A{
@Override
public void AA(){
System.out.println(2);
}
}
多态
多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。
特点
多态的前提1：是继承
多态的前提2：要有方法的重写
父类引用指向子类对象,如：Animal a = new Cat();
多态中，编译看左边，运行看右边
多态对象调用的静态方法是父类的
throws 与 throw 的区别
throw
用在方法的内部，其后跟着的是异常对象的名字
表示此处抛出异常，由方法体内的语句处理
注意：执行throw一定抛出了某种异常
throws
用在方法声明处，其后跟着的是异常类的名字
表示此方法会抛出异常，需要由本方法的调用者来处理这些异常
但是注意：这只是一种可能性，异常不一定会发生
?判断用户输入的数据是否符合正则表达式的方法String.match(正则)
Integer类中包含256个Integer缓存对象，范围是 -128~127
使用valueOf()时，如果指定范围内的值，直接访问缓存对象不新建；如果指定范围外的值，直接新建对象。
自动装箱和自动拆箱
自动装箱：把 基本类型 包装成对应的 包装类型 的过程Integer a = Integer.valueOf();
自动拆箱：从包装类型的值，自动变成 基本类型的值int i = a.intValue();