所有的代码格式

变量定义格式

数据类型  变量名  =  初始化值;

类型强行转换

`小的数据类型  变量名  =  (小的数据类型)大的数据类型/变量;

三元运算符格式

结果的数据类型  变量名  =  结果围殴boolean类型的式子  ?  结果1  :  结果2;

创建Scanner对象

Scanner  对象名  =  new  Scanner(System.in)

键盘录入整数
int 变量名 = 对象名.nexInt();

switch

switch : 分支语句,开关语句
格式:
switch(表达式){
    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
        ....
    default: 
        语句体n+1;
        break;
}

if

if : 假如 假设 如果 ...
if 的第一种格式: 
if(结果为boolean类型的式子){
	语句体;
}

if 的第二种格式:

if(结果为boolean类型的式子){
	语句体1;
}else{ //else : 其他
    语句体2;
}

if 的第三种格式

if(结果为boolean类型的式子1){
	语句体1;
}else if(结果为boolean类型的式子2){
    语句体2;
}
	..这里有很多else if..
else{ //else : 其他
    语句体n+1;
}

for

for(初始化语句1;判断条件语句2;步进表达式3){
	循环体语句4;
}

while

初始化语句1;
while(判断条件语句2){
	循环体语句4;
    步进表达式3;
}

do…while循环

初始化语句1;
do{
	循环体语句4;
    步进表达式3;
}while(判断条件语句2);

三种循环的区别

1.for循环 和 while循环,do..while循环的区别 :
    for循环初始化语句定义在循环的格式内,只在for循环的大括号内有效
    do..while和while循环定义的初始化语句在整个while所在的大括号内都有效

    当for循环结束后,不可以再次使用for循环的初始化语句变量!
        
2.do..while循环 和 while循环,for循环的区别 :
    do..while循环 无论如何都会执行一次循环体语句
    while循环,for循环 必须满足循环条件才能执行

经验之谈:
    当明确循环次数的时候推荐用for循环
    不明确循环次数的时候推荐使用while循环    `

死循环

死循环 : 停不下来的循环
for循环的死循环格式:
    for(;;){
    }
while循环的死循环格式: -> 推荐格式
    while(true){
        死循环代码
    }`

控制循环

break : 中断,结束,打断
使用位置: switch , 循环中
作用 : 用于结束 switch 和 循环	
continue :	继续
使用位置 : 循环中
作用: 用于结束本轮次的循环,从下一轮次循环的步进表达式开始执行
break 和 continue 都是配合条件使用,不会直接在循环中使用!	

循环嵌套

循环的嵌套 : 一个循环的循环体语句还是一个循环结构!
格式: (以for循环为例)
for(初始化语句;判断条件语句;步进表达式){ //外层循环
	循环体语句;
    for(初始化语句;判断条件语句;步进表达式){//内层循环
        循环体语句;
    }
}
循环嵌套 : 外层循环执行一次,内层循环要全部执行!!`

随机数

Random 对象名 = new Random();`
int 变量名 = 对象名.nextInt(m);`

学习容器

1. 如何创建容器
2. 如何使用容器的增删改查四类功能 CRUD
3. 如何遍历容器
容器 : 数组,集合,数据库`

一维数组

格式:
数据类型[] 数组名;`
初始化: 
动态初始化: 由程序员决定数组的长度,JVM根据数组的数据类型给与默认值;
	数据类型[] 数组名 = new 数据类型[m];
完整格式 : 数据类型[] 数组名 = new 数据类型[]{值1,值2,值3,值4......};
简化格式 : 数据类型[] 数组名 = {值1,值2,值3,值4......}; //推荐使用

动态初始化元素

不同数据类型的数组动态初始化默认值:
    byte,short,int,long : 0
    float,double : 0.0
    char : '\u0000' 空字符
    boolean : false
    所有元素是引用数据类型的数组 : null

数组的增删改查

改: 先查到再改
改元素 : 数组名[索引] = 修改的值;//修改指定索引位置的元素值`
查:
查元素 : 数组名[索引] 

格式解释:

	1. public static : 公共的静态的 adj. -> 今天你必须加上
	2. void : 代表方法无结果
	3. 方法名 : 命名规范-> 小驼峰
	4. () : 形参列表 -> 空的: 无形参 -> 调用方法时不需要传递数据
	5. {} : 封装特定功能的代码块

无返回值无形参的方法定义

public static void 方法名(){
//放法体:(特定功能的代码)
}

无返回值有形参的调用

 public static void 方法名(形式参数列表){
    //方法体;(特定功能的代码)
}

有返回值有形参的方法定义\

public static 返回值类型 方法名(形式参数列表){
//方法体;(特定功能的代码)
return 返回值;
}     //返回值 : 方法的结果 要求结果的数据类型必须和返回值类型一致

有返回值无参数方法的定义

public static 返回值类型 方法名{
//方法体;(特定功能的代码)
return 返回值;
}

如何定义事务描述类

public class 类名{
成员变量
成员方法}

定义成员方法

public 返回值类型 方法名 (形参列表){
方法体;
return  返回值\
}

创建对象的格式

类名 对象名 = new 类名();

成员变量和局部变量

    因为在类中的位置不同,导致作用域不同和导致在内存中的位置不同;      
	因为在内存中的位置不同,导致初始化值不同和生命周期不同;     

构造方法的格式

public 类名(形式参数列表){
方法体;
}

成员变量的访问特点

this : 打破局部的约束 强制访问本类成员位置上的变量`
super : 打破本类成员的约束 强制访问本类父类成员位置上的变量`
在第三方类中访问 : 子类对象只能访问父类所有非私有的成员和自己本类中的成员`

继承的格式

piunlic class 父类名
}
public class 子类名 extends 父类名{
}//Object 是所有类的父类

方法恶的重写Override

权限修饰符
public > protected > 不写 > private`
返回值类型
Integer < Number < Object

final的格式

public ststic 数据类型 常量名= 初始化值

自定义常量格式

public static final 数据类型 常量名 = 初始化值

抽象类的格式

public abstract class 类名{

}

抽象方法的格式

public  abstract 返回值类型 方法名(形参列表)

接口的方法格式

public interface 接口名

类和类的接口 实现 多实现接口

public class 子类 implements 父接口1 父接口2{
}

接口和接口 继承 多继承

public interface 子接口 extends 父接口1 父接口2{
}

类可以继承一个父类实现多个接口 多实现

public class 子类 extemds 父类 implements 父接口1 父接口2{
}	

特性

JDK7的成员和使用

JDK7版本的接口成员
成员变量 : 没有成员变量
自定义常量 : 接口中所有的成员变量都是自定义常量
	默认被 : public static final 修饰
构造方法 : 没有构造方法不能创建对象
普通成员方法 : 没有普通成员方法
静态成员方法 : 没有静态成员方法
抽象方法 : 接口中所有的方法都是抽象方法
默认被 : public abstract 修饰

使用步骤
创建一个实现类,让实现父接口
要么把接口中的所有抽象方法实现 要么把实现类变成抽象类
在使用接口的地方,创建的实现类对象并使用实现类对象调用方法

JDK8的成员和使用

自定义常量 
抽象方法
默认方法
格式
public default 返回值类型 方法名 (形式参数列表){
方法体;
}
默认方法被public
默认方法可以选择重写
当实现类实现多个接口时,多个接口中有同名的默认方法,实现类必须重写该默认方法
静态方法	格式
	public static 返回值类型 方法名(形式参数列表){
	方法体;
	}
	默认方法默认被 public
	静态方法就不能重写
		特殊 : 接口中的静态方法只能使用接口名调用不可以使用实现类对象调用
		
		使用步骤
		创建一个实现类,让类实现父接口
		要么吧接口中的所有的抽象方法实现/要么把实现类变成抽象类
		选择性重写父接口中的默认方法,不可以重写父接口中的静态方法
		在使用接口的地方,创建接口的实现类对象并使用实现类对象调用方法

JDK接口的还曾元和使用

自定义常量
抽象方法
默认方法
静态方法
私有方法(新增)
	普通私有(默认方法服务)
		格式
		private 返回值类型 方法名(形参列表){
		方法体;
		}
		当实现类实现父接口时,父接口中的私有方法时不需要处理的!
		静态私有(静态方法服务)
		格式	
			private static 返回值类型 方法名(形参列表){
			方法体;
			}

多态

多态前提

必须有继承或者实现关系
有方法重写
夫引用指向子类对象
	Fu 父引用 = new Zi();


向上转型: 自动
父类/父接口 父引用 = new 子类();

向下转型 : 格式
子类型 子引用 = (子类型)父引用;

多态向下转型的解决方案

if(父引用 instanceof 类型){
}
if(父引用.getClass() == 类名.class){
}

成员内部类

public class Outer{
成员位置
public class Inner
	}
}

静态成员内部类

public class Outer{
	//成员位置
	//静态成员内部类
	public static class Inner{
		}
	}

在第三方类中访问静态成员内部类的成员: 还是要先有Inner 对象

Outer.Inner inner = new Outer.Inner();

局部内部类

public class Outer{
	//类中成员方法
	public 返回值类型 方法名(形参){
		int num = 10;
		//局部内部类
		class Inner{
				}
			}
		}

在第三方类中访问内部类成员
必须要创建成员内部类的对象
		Outer.Inner inner = new Outer().new Inner();

匿名内部类

 Object obj = new Object();
 匿名对象 : new Object();

new 父类/抽象类/接口 (){
	//子类/实现类的类主体
};

权限修饰符

private < 不写 < protected < public	 

静态代码块

    格式:
    static{

    }