整型
    byte<-2^8=-128,2^8-1=127>
    short<-2^15=32768,2^15-1=32767>
    int
    long
浮点型 
    float
    double
字符型
    '字符'
    
字符串型
    "字符串"
布尔型
    true/false

// 数据范围从小到大 如int->long
long num1 = 100;

// 数据范围从小到大 如float->double
double num2 = 2.5F;

// 数据范围从小到大 如long->float
float num3 = 30L;

// long强制转换为int类型,这里存在发生 数值溢出
int num2 = (int) 6000000000L;

// double->int ，强制类型转换，这里存在发生精度损失，所有的小数值都会被舍弃掉
int num3 = (int) 3.4;

加：+
减：-
乘：*
除：/
取模: %

int num2 = 20;//混合使用，先++，变量立刻马上变成21，然后打印21
System.out.println(++num2);//21
System.out.println(num2);//21
int num3 = 30; //混合使用，后++，首先使用变量值，然后再让变量+1
System.out.println(num3++);//30
System.out.println(num3);//31

复合赋值运算符：
+= : a += 1      ->   a = a + 1
-= : a -= 1      ->   a = a - 1
*= : a *= 2      ->   a = a * 2
/= : a /= 2      ->   a = a / 2
%= : a %= 3      ->   a = a % 3

比较运算符:==、>、>=、<、<=、！=

与（并且）：&&
或（或者）：||
非（取反）：！
// &&、 || 具有短路效果，根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，节省性能
int a = 10;
System.out.println(3>4 && ++a<100);   //false，这里++a不执行!
System.out.println(a);//10
int b =20;
System.out.println(3<4||++b<100);    //ture ，这里++b不执行
System.out.println(b);//20

int  a = 30;
int  b = 20;
// 数据类型：变量名称 = 条件判断 ？ 表达式A : 表达式B;
int max = a > b ? a: b;
System.out.println("最大值为："+max);
System.out.println("a、b两者的最大值为："+(a > b ? a : b));

System.out.println("今天天气不错");
System.out.println("挺风和日丽的");
System.out.println("我们下午没事");

int age = 19
if (age>=18){
    System.out.println("进入网吧，开始high!");
    System.out.println("遇到一群猪队友，开始骂街");
    System.out.println("感觉不爽，结账走人。");
}

if ( a%2 == 0 ){
    System.out.println(a+"是偶数");
} else {
    System.out.println(a+"是奇数");
}

int x = 10;
int y;
if ( x >= 3 ){
    y = 2 * x + 1;
} else if (x > -1 && x < 3){
    y = 2 * x;
} else{
    y = 2 * x - 1;
}
System.out.println("结果是："+ y);

switch(条件){
	case 条件1:
	语句体;
	break;
	
	...
	case 条件n:
	语句体;
	break;
	
	default:
	语句体;
	break;
}

for (初始化表达式1; 布尔表达式2; 步进表达式4){
	循环体3;
    }

标准格式：
    while(条件){
        循环体
    }
拓展格式：
    初始化语句1;
    while(条件2){
        循环体3;
        步进表达式4;
    }

do-while 循环标准格式：
    do{
        循环体
    } while(条件判断);

do-while 循环扩展格式：
    初始化语句1；
    do{
        循环体3；
        步进语句4；
    } while(条件判断2);

定义格式：
public static void 方法名称(){
    方法体
}

调用格式：
方法名称();

完整的格式：
修饰符 返回值类型 方法名称(参数类型 参数名称，...){
    方法体;
    return 返回值;
}

public static int sum(int a, int b) {
        System.out.println("有两个参数的方法执行！");
        return a + b;
    }

public static int sum(double a, double b) {
    System.out.println("有两个参数的方法执行！");
    return (int) (a + b);
}

public static int sum(int a, double b) {
    System.out.println("有两个参数的方法执行！");
    return (int) (a + b);
}

public static int sum(double a, int b) {
    System.out.println("有两个参数的方法执行！");
    return (int) (a + b);
}

public static int sum(int a, int b, int c) {
    System.out.println("有三个参数的方法执行！");
    return a + b + c;
}

public static int sum(int a, int b, int c, int d) {
    System.out.println("有四个参数的方法执行！");
    return a + b + c + d;
}

int[] arrayD;
arrayD = {10,20,30};

数组名.fori
for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

for(int num:array){
	System.out.println(num);
}

ArrayList<String> al = new ArrayList<>();
System.out.println(al); //  []

public class Demo04ArrayListEach {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<>();
        al.add("迪丽热巴");
        al.add("古力娜扎");
        al.add("马尔扎哈");

        // 变量集合
        for (int i = 0; i < al.size(); i++) {
            System.out.println("元素为："+al.get(i));
        }
    }
}

public class Demo01ArrayListRandom {
    public static void main(String[] args) {
        Random r = new Random();
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < 6; i++) {
            list.add(r.nextInt(33)+1);
        }
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

public class Demo03ArrayListPrint {
    public static void main(String[] args) {
        ArrayList<Integer> al = new ArrayList<>();
        al.add(12);
        al.add(18);
        al.add(10);
        System.out.println(al); // [12, 18, 10]
        System.out.println("==============");
        System.out.println("按照格式要求输出的是");
        printArrayList(al);
    }

    public static void printArrayList(ArrayList<Integer> al) {
        System.out.print("{");
        for (int i = 0; i < al.size(); i++) {
            int num  = al.get(i);
            if (i == al.size() - 1) {
                System.out.println(num + "}");
            } else {
                System.out.print(num + "@");
            }
        }
    }
}

class 类名称
{
	// 定义属性（成员变量）
	数据类型 属性；      //零到多个属性
	// 定义构造函数
	类名称（参数，…）{   //零个到多个构造方法
	
	}
	// 定义方法
	返回值的数据类型 方法名称（参数1，参数2…） //零到多个方法
	{
    	程序语句 ;
   	 	return 表达式 ;
	}
}

public class Demo04PhoneParam {
    public static void main(String[] args) {
        Phone one = new Phone();
        one.brand = "苹果";
        one.color = "土豪金";
        one.price = 8388.0;
        method(one);//传递进去的是对象one的地址值
    }
    public static void method(Phone param){
        System.out.println("传入方法的是：");
        System.out.println(param); // cn.itcast.day06.demo02.Phone@b4c966a
    }
}

public class Demo05PhoneReturn {
    public static void main(String[] args) {
        Phone two = getPhone();
        System.out.println("方法返回的对象是：");
        System.out.println(two); // cn.itcast.day06.demo02.Phone@b4c966a
    }
    public static Phone getPhone(){
        Phone one = new Phone();
        one.price=8388.0;
        one.color="玫瑰金";
        one.brand="苹果";
        return one;
    }
}

public class Person {
    String name;
    public void showName(){
        System.out.println("我叫"+name);
    }
}
public class Demo01Anoymous {
    public static void main(String[] args) {
        // 匿名对象
        new Person().name = "赵又廷"; //第一个对象
        new Person().showName();    //第二个对象  我叫：null
    }
}

public class Person {
	private int age;
    // 这个成员方法，专门用于向age设置数据
    public void setAge(int num) {
        if (num < 100 & num >= 0) {
            age = num;
        } else {
            System.out.println("数据不合理！");
        }
    }

    // 这个成员方法，专门用于获取age数据
    public int getAge() {
        return age;
    }
}

public class Demo03Person {
    public static void main(String[] args) {
          Person person = new Person();
        // person.age = 35; // 直接访问private方法，错误写法！
    	person.setAge(-20);
    }
}       

public 类名称 (参数类型 参数名称){
   方法体
}

import java.util.Scanner;

Scanner sc = new Scanner(System.in);  //System.in 代表从键盘输入

int num = sc.nextInt();

import java.util.Random;
Random r = new Random();

int num = r.nextInt();//获取随机的int数字，范围为int所有范围，有正负之分
System.out.println("随机数为：" + num);

int num1 = r.nextInt(3);//参数代表范围，左闭右开区间 [0 3)
System.out.println("随机参数为" + num1);

public class Demo04Random {
    public static void main(String[] args) {
        int r = new Random().nextInt(10) + 1; // [1,11)
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入你猜测的数字：");
        while(true){
            int num = sc.nextInt();

            if (num < r) {
                System.out.println("数字小了,请重新输入");

            } else if (num > r) {
                System.out.println("数字大了，请重新输入");

            } else {
                System.out.println("恭喜你，你猜对了！");
                break;//如果猜中，不再重试
            }
        }
        System.out.println("游戏结束！GameOver!");
    }
}

public class Demo01String {
    public static void main(String[] args) {
        // 使用空参构造,public String();
        String str1 = new String();;
        System.out.println("第一个字符串：" + str1);

        // 根据字符数组创建字符串，public String(char[] array);
        char[] charArray = {'A', 'B', 'C'};
        String str2 = new String(charArray);
        System.out.println("第二个字符串：" + str2);

        // 根据字节数组创建字符串，Public string(byte[] array);
        byte[] byteArray = {97, 98, 99};
        String str3 = new String(byteArray);
        System.out.println("第三个字符串：" + str3);

        // 直接创建，直接写上双引号，就是字符串对象
        String str4 = "Hello,World!";
        System.out.println("第四个字符串：" + str4);
    }
}

// 正常的切分规则
String str1 = "aaa,bbb,ccc";
String[] array1 = str1.split(",");
// 如果按照英文句点“.”进行切分，则需要改为“\\.”
String str3 = "XXX.YYY.ZZZ";
String[] array3 = str3.split("\\.");

public class Demo04StringConvert {
    public static void main(String[] args) {
        char[] chars = "HelloWorld".toCharArray();
        System.out.println(chars);
        //  这里注意【字符串数组】的长度用  ".length"
        // 【字符串】的长度用   ".length();"
        System.out.println(chars.length);
        System.out.println("============");

        // 转换为字节数组
        byte[] charBytes = "abc".getBytes();
        for (int i = 0; i < charBytes.length; i++) {
            System.out.println(charBytes[i]);
        }
        System.out.println("=============");

        // 替换字符串
        String str1 = "How do you do ?";
        String strNew = str1.replace("o", "*");
        System.out.println(strNew);//H*w d* y*u d* ?
        System.out.println("==============");

        String lang1 = "会不会玩呀！你大爷的！";
        String lang2 = lang1.replace("你大爷的", "****");
        System.out.println(lang2); // 会不会玩呀！****！
    }
}

public class Demo07StringCount {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String input = sc.next();

        int countUpper = 0;
        int countLower = 0;
        int countNumber = 0;
        int countOther = 0;

        char[] charArray = input.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            char ch = charArray[i];
            if ('A' <= ch && ch <= 'Z') {
                countUpper++;
            } else if (ch <= 'z' && ch >= 'a') {
                countLower++;
            } else if (ch >= '0' && ch <= '9') {
                countNumber++;
            } else {
                countOther++;
            }
        }
        System.out.println("大写字母有：" + countUpper);
        System.out.println("小写字母有：" + countLower);
        System.out.println("数字有：" + countNumber);
        System.out.println("其他符号有：" + countOther);
    }
}

public class Student {
    private int id; //学号
    private String name;//姓名
    private int age;// 年龄
    // 
    static String room;//所在教室
    private static int countId = 0; //用来统计学生数量

    public Student() {
        this.id = ++countId;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++countId;
    }
}

public class Demo01StaticField {
    public static void main(String[] args) {
        // 姓名：黄容,年龄：16,教室：1804班,学号：1
        Student one = new Student("黄容", 16);
        Student.room = "1804班";
        System.out.println("姓名：" + one.getName()
                + ",年龄：" + one.getAge() + ",教室：" + one.room
                + ",学号：" + one.getId());

        // 姓名：null,年龄：0,教室：1804班,学号：1
        Student aa = new Student();
        System.out.println("姓名：" + aa.getName()
                + ",年龄：" + aa.getAge() + ",教室：" + aa.room
                + ",学号：" + aa.getId());

        // 姓名：郭靖,年龄：18,教室：1804班,学号：3
        Student two = new Student("郭靖", 18);
        System.out.println("姓名：" + two.getName()
                + ",年龄：" + two.getAge() + ",教室：" + two.room
                + ",学号：" + two.getId());
    }
}

public class MyClass {
    int num;
    static int numStatic;
    public void method() {
        System.out.println("这是一个普通的成员方法");
        // 成员方法可以访问成员变量
        System.out.println(num);
        // 成员方法可以访问静态变量
        System.out.println(numStatic);
    }
    public static void staticMethod() {
        System.out.println("这是一个静态方法");
        // 静态方法可以访问静态变量
        System.out.println(numStatic);

        //静态方法不可以直接访问成员变量
//        System.out.println(num);

        // 静态方法中不可使用this关键字
//        System.out.println(this);
    }
}

public class 类名称{
static{
     // 静态代码块的内容
   }
}

public class Person {
    static {
        int num = 10;
        System.out.println("静态代码块执行！");
    }
    public Person(int num){
        System.out.println(num);
        System.out.println("构造方法执行！");
    }
}

public class Demo04Static {
    public static void main(String[] args) {
        Person one = new Person(5);
       // 静态代码块执行！
       // 5
       // 构造方法执行！
    }
}

public class 父类名称(){
    // ...
}

public class 子类名称 extends 父类名称{
       // ...
}

public class Fu {
    int numFu = 10;
    int num = 100;
    public void methodFu(){
        // 使用的是本类当中的num
        System.out.println(num);
    }
}

public class Zi extends Fu{
    int numZi = 20;
    int num = 200;
    public void methodZi(){
        // 使用的是本类当中的num
        System.out.println(num);
    }
}

System.out.println(zi.num);//200

// 这里调用的是子类方法，变量优先选用子类的变量，没有则往上找
zi.methodZi();//200
zi.methodFu();//100

public class Zi extends Fu{
    int num =20;
    public void method(){
        int num = 30;
        System.out.println(num);// 30 局部变量
        System.out.println(this.num);// 20 本类的成员变量
        System.out.println(super.num);//10 父类的成员变量
    }
}

public class Zi extends Fu {
    int num = 20;
    public Zi(){
        super();
    }
    
    public void methodZi() {
        System.out.println(super.num);// 父类中的num
        System.out.println(num);
    }
    
    public void method(){
        super.method(); // 访问父类中的method()方法
        System.out.println("子类成员方法");
    }
}

public class Zi extends Fu {
    int num = 20;
//   1.在本类的成员方法中，访问本类的成员变量
    public void showNum() {
        int num = 10;
        System.out.println(num);// 局部变量
        System.out.println(this.num);// 本类中的成员变量
        System.out.println(super.num);// 父类中的成员变量
    }
//  2.在本类的成员方法中，访问本类的另一个成员方法
    public void methodA() {
        System.out.println("AAA");
    }

    public void methodB() {
        this.methodA();
        System.out.println("BBB");
    }
//  3.在本类的构造方法中，访问本类的另一个构造方法
//  this(参数)调用也必须是构造方法的第一个语句，且只能使用一次
    public Zi() {
//        this(100);// 本类的无参构造，调用本类的有参构造
//        this(10,20);
    }

    public Zi(int n) {
        this(20,30);
    }
    public Zi(int n,int m) {
        this();
    }

}

public > protected > (default) > private

public class Fu {
    public void methodFu(){
        System.out.println("父类方法执行！");
    }
    public void method(){
        System.out.println("父类重名方法执行！");
    }
}

public class Zi extends Fu{
    public void methodZi(){
        System.out.println("子类方法执行！");
    }
    public void method(){
        System.out.println("子类重名方法执行！");
    }
}

public class Demo01ExtendsMethod {
    public static void main(String[] args) {
        Zi zi = new Zi();

        zi.methodFu();
        zi.methodZi();
        System.out.println("==============");
		// 创建的是子类对象(new),就优先用子类方法
        zi.method(); //  子类重名方法执行！
    }
}

public class Phone {
    public void call() {
        System.out.println("打电话");
    }

    public void send() {
        System.out.println("发短信");
    }

    public void show() {
        System.out.println("显示号码");
    }
}
    
public class NewPhone extends Phone {
    @Override
    public void show(){
//        System.out.println("显示号码");
        super.show();
        System.out.println("显示头像");
        System.out.println("显示姓名");
    }
}

public class Fu {
    public Fu(){
        System.out.println("父类无参构造方法");
    }
    public Fu(int num){
        System.out.println("父类有参构造方法");
    }
}

public class Zi extends Fu {

    public Zi() {
        super();//调用父类无参数构造方法
//        super(10);//调用父类有参数构造方法
        System.out.println("子类构造方法");
    }

    public void method() {
//      错误写法！只有子类构造方法才能调用父类构造方法
//        super();
    }
}

修饰符 abstract 返回值类型 方法名称();

修饰符 abstract class 类名称{
	// ... 
}

public abstract class Animal {
    // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定。
    public abstract void eat();
    // 普通的成员方法
    public void normalMethod(){
        System.out.println("这是一个正常的成员方法！");
    }
}

public class Cat extends Animal {
    @Override
    public void eat(){
        System.out.println("猫吃鱼！");
    }
}

public class DemoMain {
    public static void main(String[] args) {
//        错误写法！不能直接创建抽象类对象
//        Animal animal = new Animal();
        Cat cat = new Cat();
        cat.eat();
    }
}

public interface MyInterfaceAbstract {
    // 定义抽象方法  public abstract 返回值类型 方法名称(参数列表);
    public abstract void methodAbs1();
    // 这也是抽象方法
    abstract void methodAbs2();
    // 这也是抽象方法
    public void methodAbs3();
    // 这也是抽象方法
    void methodAbs4();
}

public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{

    @Override
    public void methodAbs1() {
        System.out.println("这是第一个方法！");
    }

    @Override
    public void methodAbs2() {
        System.out.println("这是第二个方法！");
    }

    @Override
    public void methodAbs3() {
        System.out.println("这是第三个方法！");
    }

    @Override
    public void methodAbs4() {
        System.out.println("这是第四个方法！");
    }
}

public class Demo01Interface {
    public static void main(String[] args) {
        // 创建接口的实现类对象
        MyInterfaceAbstractImpl myInterface = new MyInterfaceAbstractImpl();
        myInterface.methodAbs1();
        myInterface.methodAbs2();
        myInterface.methodAbs3();
        myInterface.methodAbs4();
    }
}

public **default** 返回值类型 方法名称(参数列表){
	// 方法体
}

public interface MyInterfaceDefault {
    // 抽象方法
    public abstract void methodAbs();
//    // 新添加一个抽象方法，根据这个接口【MyInterfaceDefault】创建的【实现类】就会出错
//    public abstract void methodAbs2();

    // 新添加的方法，改成默认方法就可以解决问题
    public default void methodDefault(){
        System.out.println("这是新添加的默认方法！");
    }

}

public **static** 返回值类型 方法名称(参数列表){
	// 方法体
}

public interface MyInterfaceStatic {
    public static void methodStatic(){
        System.out.println("这是接口的静态方法！");
    }
}

public class Demo03Interface {
    public static void main(String[] args) {
        // 创建实现类对象
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
        // 错误写法
//        impl.methodStatic();
        // 应该通过接口名称.静态方法名 进行调用
        MyInterfaceStatic.methodStatic();
    }
}

public interface MyInterfacePrivateB {
    public static void methodStatic1() {
        System.out.println("这是一个静态方法1");
        methodStaticCommon();
    }

    public static void methodStatic2() {
        System.out.println("这是一个静态方法2");
        methodStaticCommon();
    }

    private static void methodStaticCommon() {
        System.out.println("AAA");
        System.out.println("BBB");
    }
}

public interface MyInterface extends MyInterfaceA, MyInterfaceB {
    public abstract void method();
//    多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，
    @Override
    default void methodDefault() {
        System.out.println("默认方法重复了");
    }
}

public class MyInterfaceImpl implements MyInterface{
    @Override
    public void method() {
        System.out.println("子接口方法");
    }

    @Override
    public void methodA() {
        System.out.println("接口A方法");
    }

    @Override
    public void methodB() {
        System.out.println("接口B方法");
    }

    @Override
    public void methodCommon() {
        System.out.println("A、B接口公共方法");
    }
//    多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，实现类中可以不用对重复的默认方法进行覆盖重写
//    @Override
//    public void methodDefault() {
//        System.out.println("默认接口重复");
//    }
}

public class Fu {
    int num = 10;
}

public class Zi extends Fu {
    int num = 20;
    @Override
    public void showNum() {
        System.out.println(num);
    }
}

Fu obj = new Zi();

System.out.println(obj.num);  //10

obj.showNum(); //20

public class Zi extends Fu {
    int num = 20;
	@Override
    public void showNum() {
        System.out.println(num);
    }
}

obj.showNum();//20

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    // 子类特有方法
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

public class Demo01Main {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.catchMouse();  // 错误写法
        // 向下转型
        Cat cat= (Cat) animal;
        cat.catchMouse(); // 猫抓老鼠
    }
}