Safe: 13-代码审计进阶

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
    }
}

编译：javac 文件名.java
范例：javac HelloWorld.java  // 出生成HelloWorld.class文件

执行：java 类名
范例：java HelloWorld

/*
  常量的分类：
  字符串常量 "123" "abc"
  整数常量: 100 1 -1 -100
  小数常量: 1.1 1.2 -1.1 -1.2
  字符常量: 'a' '1' '你'
  字符'' 有且仅有一个字符
  布尔常量: true false
  空常量: null
*/
public class Demo01{
    public static void main(String[] args){
        // 字符串常量 "123" "abc"
        System.out.println("abc");

        // 整数常量
        System.out.println(100);
        System.out.println(-100);

        //小数常量
        System.out.println(1.1);
        System.out.println(-1.1);

        // 字符常量
        System.out.println('a');
        System.out.println('你');
        // System.out.println('');
        System.out.println(' ');

        // 布尔常量: true false
        System.out.println(true);
        System.out.println(false);

        // null是不能直接打印，有特殊应用的，在后面的数组 集合 对象中使用
        // System.out.println(null);
    }
}

1B（字节） = 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB
1EB = 1024PB

double num = 10; // 将int类型的10直接赋值给double类型
System.out.println(num); // 输出10.0

double num1 = 5.5;
int num2 = (int) num1; // 将double类型的num1强制转换为int类型
System.out.println(num2); // 输出5（小数位直接舍弃）

数据范围从小到大
- byte
- short, char
- int
- long
- float
- double

int a = 'a';
System.out.println(a); // 将输出97

byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;
// 第三行代码会报错，b1和b2会自动转换为int类型，计算结果为int，int赋值给byte需要强制类型转换。
// 修改为:
int num = b1 + b2;
// 或者：
byte b3 = (byte) (b1 + b2);

符号 作用 说明
+ 加 参看小学一年级
- 减 参看小学一年级
* 乘 参看小学二年级，与“×”相同
/ 除 参看小学二年级，与“÷”相同
% 取余 获取的是两个数据做除法的余数

int a = 10;
int b = 3;
System.out.println(a / b); // 输出结果3
System.out.println(a % b); // 输出结果1

符号 作用 说明
= 赋值 a=10，将10赋值给变量a
+= 加后赋值 a+=b，将a+b的值给a
-= 减后赋值 a-=b，将a-b的值给a
*= 乘后赋值 a*=b，将a×b的值给a
/= 除后赋值 a/=b，将a÷b的商给a
%= 取余后赋值 a%=b，将a÷b的余数给a

short s = 10;
s = s + 10; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度
s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s +10);

符号 作用 说明
++ 自增 变量的值加1
-- 自减 变量的值减1

int i = 10;
i++; // 单独使用
System.out.println("i:" + i); // i:11

int j = 10;
++j; // 单独使用
System.out.println("j:" + j); // j:11

int x = 10;
int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
System.out.println("x:" + x + ", y:" + y); // x:11，y:10

int m = 10;
int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
System.out.println("m:" + m + ", m:" + m); // m:11，m:11

int x = 10;
int y = x++ + x++ + x++;
System.out.println(y); // y的值是多少？
/*
解析，三个表达式都是++在后，所以每次使用的都是自增前的值，但程序自左至右执行，所
以第一次自增时，使用的是10进行计算，但第二次自增时，x的值已经自增到11了，所以第
二次使用的是11，然后再次自增。。。
所以整个式子应该是：int y = 10 + 11 + 12;
输出结果为33。
*/
注意：通过此练习深刻理解自增和自减的规律，但实际开发中强烈建议不要写这样的代码！小心挨打！

符号 说明
==   a==b，判断a和b的值是否相等，成立为true，不成立为false
!=   a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>    a>b，判断a是否大于b，成立为true，不成立为false
>=   a>=b，判断a是否大于等于b，成立为true，不成立为false
<    a<b，判断a是否小于b，成立为true，不成立为false
<=   a<=b，判断a是否小于等于b，成立为true，不成立为false

关系运算符的结果都是boolean类型，要么是true，要么是false。
千万不要把 “==”误写成“=”，"==" 是判断是否相等的关系，"="是赋值。

int a = 10;
int b = 20;
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a > b); // false
System.out.println(a >= b); // false
System.out.println(a < b); // true
System.out.println(a <= b); // true
// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
// 比较运算符经常结合 if 判断使用

boolean flag = a > b;
System.out.println(flag); // 输出false

符号 作用 说明
& 逻辑与 a&b，a和b都是true，结果为true，否则为false
| 逻辑或 a|b，a和b都是false，结果为false，否则为true
^ 逻辑异或 a^b，a和b结果不同为true，相同为false
! 逻辑非 !a，结果和a的结果正好相反

//定义变量
int i = 10;
int j = 20;
int k = 30;

//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((i > j) & (i > k)); //false & false,输出false
System.out.println((i < j) & (i > k)); //true & false,输出false
System.out.println((i > j) & (i < k)); //false & true,输出false
System.out.println((i < j) & (i < k)); //true & true,输出true
System.out.println("--------");

//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((i > j) | (i > k)); //false | false,输出false
System.out.println((i < j) | (i > k)); //true | false,输出true
System.out.println((i > j) | (i < k)); //false | true,输出true
System.out.println((i < j) | (i < k)); //true | true,输出true
System.out.println("--------");

//^ “异或”，相同为false，不同为true
System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
System.out.println("--------");

//! “非”，取反
System.out.println((i > j)); //false
System.out.println(!(i > j)); //!false，,输出true

关系表达式 ? 表达式1 : 表达式2;

int a = 10;
int b = 20;
int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值

import java.util.Scanner;
public class ScannerDemo {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        //接收数据
        int x = sc.nextInt();
        //输出数据
        System.out.println("x:" + x);
    }
}

import java.util.Scanner;
public class ScannerTest {
    public static void main(String[] args) {
        //身高未知，采用键盘录入实现。首先导包，然后创建对象。
        Scanner sc = new Scanner(System.in);
        //键盘录入三个身高分别赋值给三个变量。
        System.out.println("请输入第一个和尚的身高：");
        int height1 = sc.nextInt();
        System.out.println("请输入第二个和尚的身高：");
        int height2 = sc.nextInt();
        System.out.println("请输入第三个和尚的身高：");
        int height3 = sc.nextInt();
        //用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
        int tempHeight = height1 > height2 ? height1 : height2;
        //用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
        int maxHeight = tempHeight > height3 ? tempHeight :
            height3;
        //输出结果。
        System.out.println("这三个和尚中身高最高的是：" + maxHeight +"cm");
    }
}

if (关系表达式) {
  语句体;
}

public class IfDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        //定义两个变量
        int a = 10;
        int b = 20;
        //需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
        if(a == b) {
            System.out.println("a等于b");
        }
        //需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
        int c = 10;
        if(a == c) {
            System.out.println("a等于c");
        }
        System.out.println("结束");
    }
}

if (关系表达式) {
  语句体1;
} else {
  语句体2;
}

public class IfDemo02 {
    public static void main(String[] args) {
        System.out.println("开始");
        //定义两个变量
        int a = 10;
        int b = 20;
        b = 5;
        //需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，在控制台输出：a的值不大于b
        if(a > b) {
            System.out.println("a的值大于b");
        } else {
            System.out.println("a的值不大于b");
        }
        System.out.println("结束");
    }
}

import java.util.Scanner;
public class IfTest01 {
    public static void main(String[] args) {
        //为了体现任意给出一个整数，采用键盘录入一个数据。(导包，创建对象，接收数据)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int number = sc.nextInt();
        //判断整数是偶数还是奇数要分两种情况进行判断，使用if..else结构
        //判断是否偶数需要使用取余运算符实现该功能 number % 2 == 0
        //根据判定情况，在控制台输出对应的内容
        if(number%2 == 0) {
            System.out.println(number + "是偶数");
        } else {
            System.out.println(number + "是奇数");
        }
    }
}

if (关系表达式1) {
    语句体1;
} else if (关系表达式2) {
    语句体2;
}
…
else {
    语句体n+1;
}

import java.util.Scanner;
public class IfDemo03 {
    public static void main(String[] args) {
        System.out.println("开始");
        // 需求：键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个星期数(1-7)：");
        int week = sc.nextInt();
        if(week == 1) {
            System.out.println("星期一");
        } else if(week == 2) {
            System.out.println("星期二");
        } else if(week == 3) {
            System.out.println("星期三");
        } else if(week == 4) {
            System.out.println("星期四");
        } else if(week == 5) {
            System.out.println("星期五");
        } else if(week == 6) {
            System.out.println("星期六");
        } else {
            System.out.println("星期日");
        }
        System.out.println("结束");
    }
}

import java.util.Scanner;
public class IfTest02 {
    public static void main(String[] args) {
        //小明的考试成绩未知，可以使用键盘录入的方式获取值
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个分数：");
        int score = sc.nextInt();
        //由于奖励种类较多，属于多种判断，采用if...else...if格式实现
        //为每种判断设置对应的条件
        //为每种判断设置对应的奖励
        //数据测试：正确数据，边界数据，错误数据
        if(score>100 || score<0) {
            System.out.println("你输入的分数有误");
        } else if(score>=95 && score<=100) {
            System.out.println("山地自行车一辆");
        } else if(score>=90 && score<=94) {
            System.out.println("游乐场玩一次");
        } else if(score>=80 && score<=89) {
            System.out.println("变形金刚玩具一个");
        } else {
            System.out.println("胖揍一顿");
        }
    }
}

switch (表达式) {
case 值1:
    语句体1;
    break;
case 值2:
    语句体2;
    break;
    ...
default:
    语句体n+1;
    break;
}

public class Demo1 {
  public static void main(String[] args) {
    //键盘录入月份数据，使用变量接收
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个月份：");
    int month = sc.nextInt();
    //case穿透
    switch(month) {
      case 1:
      case 2:
      case 12:
        System.out.println("冬季");
        break;
      case 3:
      case 4:
      case 5:
        System.out.println("春季");
        break;
      case 6:
      case 7:
      case 8:
        System.out.println("夏季");
        break;
      case 9:
      case 10:
      case 11:
        System.out.println("秋季");
        break;
      default:
        System.out.println("你输入的月份有误");
   }
 }
}

for (初始化语句;条件判断语句;条件控制语句) {
    循环体语句;
}

①执行初始化语句
②执行条件判断语句，看其结果是true还是false
   如果是false，循环结束
   如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续

public class ForTest01 {
    public static void main(String[] args) {
        //需求：输出数据1-5
        for(int i=1; i<=5; i++) {
            System.out.println(i);
        }
        System.out.println("--------");
        //需求：输出数据5-1
        for(int i=5; i>=1; i--) {
            System.out.println(i);
        }
    }
}

public class ForTest02 {
    public static void main(String[] args) {
        //求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
        int sum = 0;
        //从1开始到5结束的数据，使用循环结构完成
        for(int i=1; i<=5; i++) {
            //将反复进行的事情写入循环结构内部
            // 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量sum 中
            sum += i;
            /*
              sum += i; sum = sum + i;
              第一次：sum = sum + i = 0 + 1 = 1;
              第二次：sum = sum + i = 1 + 2 = 3;
              第三次：sum = sum + i = 3 + 3 = 6;
              第四次：sum = sum + i = 6 + 4 = 10;
              第五次：sum = sum + i = 10 + 5 = 15;
            */
        }
        //当循环执行完毕时，将最终数据打印出来
        System.out.println("1-5之间的数据和是：" + sum);
    }
}

public class ForTest03 {
    public static void main(String[] args) {
        //求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
        int sum = 0;
        //对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
        for(int i=1; i<=100; i++) {
            //对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
            if(i%2 == 0) {
                sum += i;
            }
        }
        //当循环执行完毕时，将最终数据打印出来
        System.out.println("1-100之间的偶数和是：" + sum);
    }
}

public class ForTest04 {
    public static void main(String[] args) {
        //输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
        for(int i=100; i<1000; i++) {
            //在计算之前获取三位数中每个位上的值
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/10/10%10;
            //判定条件是将三位数中的每个数值取出来，计算立方比较是否相等
            if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
                //输出满足条件的数字就是水仙花数
                System.out.println(i);
            }
        }
    }
}

public class ForTest05 {
    public static void main(String[] args) {
        //定义变量count，用于保存“水仙花数”的数量，初始值为0
        int count = 0;
        //输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
        for(int i=100; i<1000; i++) {
            //在计算之前获取三位数中每个位上的值
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/10/10%10;
            //在判定水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1
            if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
                count++;
            }
        }
        //打印输出最终结果
        System.out.println("水仙花共有：" + count + "个");
    }
}

初始化语句;
while (条件判断语句) {
    循环体语句;
    条件控制语句;
}

①执行初始化语句
②执行条件判断语句，看其结果是true还是false
  如果是false，循环结束
  如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续

public class WhileDemo {
    public static void main(String[] args) {
        //需求：在控制台输出5次"HelloWorld"
        //for循环实现
        for(int i=1; i<=5; i++) {
            System.out.println("HelloWorld");
        }
        System.out.println("--------");
        //while循环实现
        int j = 1;
        while(j<=5) {
            System.out.println("HelloWorld");
            j++;
        }
    }
}

public class WhileTest {
    public static void main(String[] args) {
        //定义一个计数器，初始值为0
        int count = 0;
        //定义纸张厚度
        double paper = 0.1;
        //定义珠穆朗玛峰的高度
        int zf = 8844430;
        //因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
        //折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
        while(paper <= zf) {
            //循环的执行过程中每次纸张折叠，纸张的厚度要加倍
            paper *= 2;
            //在循环中执行累加，对应折叠了多少次
            count++;
        }
        //打印计数器的值
        System.out.println("需要折叠：" + count + "次");
    }
}

初始化语句;
do {
    循环体语句;
    条件控制语句;
}while(条件判断语句);

① 执行初始化语句
② 执行循环体语句
③ 执行条件控制语句
④ 执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
⑤ 回到②继续

public class DoWhileDemo {
    public static void main(String[] args) {
        //需求：在控制台输出5次"HelloWorld"
        //for循环实现
        for(int i=1; i<=5; i++) {
            System.out.println("HelloWorld");
        }
        System.out.println("--------");
        //do...while循环实现
        int j = 1;
        do {
            System.out.println("HelloWorld");
            j++;
        }while(j<=5);
    }
}

public static void main(String[] args) {
    //外循环控制小时的范围，内循环控制分钟的范围
    for (int hour = 0; hour < 24; hour++) {
        for (int minute = 0; minute < 60; minute++) {
            System.out.println(hour + "时" + minute + "分");
        }
        System.out.println("--------");
    }
}

1. 定义外层循环控制有多少行
 for(int i = 1 ; i <= 9 i ++)
2. 定义内层循环控制每一行输出多少个数据
 for(int j = 1 ; j <= i ; j++)
3. 拼接输出
 1 * 1 = 1
 1 * 2 = 2 2 * 2 = 4

public class TestJJ{
    public static void main(String[] args){
        for(int i = 1 ; i <= 9;i ++){
            for(int j = 1 ; j <= i ; j++){
                System.out.print(j + " * " + i + " = " + (i*j)
                                 +"\t");
            }
            System.out.println();
        }
    }
}

导入包
import java.util.Random;

创建对象
Random r = new Random();

产生随机数
int num = r.nextInt(10);

import java.util.Random;
public class RandomDemo {
    public static void main(String[] args) {
        //创建对象
        Random r = new Random();
        //用循环获取10个随机数
        for(int i=0; i<10; i++) {
            //获取随机数
            int number = r.nextInt(10);
            System.out.println("number:" + number);
        }
        //需求：获取一个1-100之间的随机数
        int x = r.nextInt(100) + 1;
        System.out.println(x);
    }
}

程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
  当猜错的时候根据不同情况给出相应的提示
  如果猜的数字比真实数字大，提示你猜的数据大了
  如果猜的数字比真实数字小，提示你猜的数据小了
  如果猜的数字与真实数字相等，提示恭喜你猜中了

import java.util.Random;
import java.util.Scanner;
public class RandomTest {
    public static void main(String[] args) {
        //要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
        Random r = new Random();
        int number = r.nextInt(100) + 1;
        while(true) {
            //使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你要猜的数字：");
            int guessNumber = sc.nextInt();
            //比较输入的数字和系统产生的数据，需要使用分支语句。
            //这里使用if..else..if..格式，根据不同情况进行猜测结果显示
            if(guessNumber > number) {
                System.out.println("你猜的数字" + guessNumber + "大了");
            } else if(guessNumber < number) {
                System.out.println("你猜的数字" + guessNumber + "小了");
            } else {
                System.out.println("恭喜你猜中了");
                break;
            }
        }
    }
}

数据类型[] 数组名;

int[] arr;    
double[] arr;   
char[] arr;

数据类型 数组名[];

int arr[];
double arr[];
char arr[];

数据类型[] 数组名 = new 数据类型[数组长度];

int[] arr = new int[3];

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};

数据类型[] 数组名 = {元素1,元素2,...};

public class ArrayDemo {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {1, 2, 3};
        //输出数组名
        System.out.println(arr);
        //输出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

数组名[索引];

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];
        //输出数组名
        System.out.println(arr); //[I@880ec60
        //输出数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

int[] arr = new int[3];

//问题1： 怎么向数组中存储元素
// 语法： 数组名[下标] = 值
arr[0] = 90;
arr[1] = 70;
arr[2] = 60;
// arr[3] = 60; // 报错，数组下标越界，不能等于大于数组的长度

//问题2： 怎么从数组中获取元素
//语法： 数组名[下标]
System.out.println(arr[0]);
int t = arr[0];

//问题3： 怎么计算数组的长度
//语法： arr.length
System.out.println(arr.length);

区域名称 作用
寄存器
给CPU使用，和我们开发无关。

本地方法栈
JVM在使用操作系统功能的时候使用，和我们开发无关。

方法区
存储可以运行的class文件。

堆内存
存储对象或者数组，new来创建的，都存储在堆内存。

方法栈
方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[3]);
    }
}

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];
        //把null赋值给数组
        arr = null;
        System.out.println(arr[0]);
    }
}

public class ArrayTest01 {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 5 };
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
    }
}

public class ArrayTest01 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11, 22, 33, 44, 55};
        //使用通用的遍历格式
        for(int x=0; x<arr.length; x++) {
            System.out.println(arr[x]);
        }
    }
}

public class ArrayTest01 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11, 22, 33, 44, 55};
        //使用通用的遍历格式
        for(int i : arr ) {
            System.out.println(i);
        }
    }
}

public class ArrayTest02 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {12, 45, 98, 73, 60};
        //定义一个变量，用于保存最大值
        //取数组中第一个数据作为变量的初始值
        int max = arr[0];
        //与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中
        for(int x=1; x<arr.length; x++) {
            if(arr[x] > max) {
                max = arr[x];
            }
        }
        //循环结束后打印变量的值
        System.out.println("max:" + max);
    }
}

数组最远端的元素互换位置。
实现反转，就需要将数组最远端元素位置交换
定义两个变量，保存数组的最小索引和最大索引
两个索引上的元素交换位置
最小索引++，最大索引--，再次交换位置
最小索引超过了最大索引，数组反转操作结束

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    /*
      循环中定义变量min=0最小索引
      max=arr.length‐1最大索引
      min++,max‐‐
    */
    for (int min = 0, max = arr.length - 1; min <= max; min++, max--) {     
        //利用第三方变量完成数组中的元素交换
        int temp = arr[min];
        arr[min] = arr[max];
        arr[max] = temp;
    }
    // 反转后，遍历数组
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}

public static void fire() {
  System.out.println("准备发射5发炮弹");
  System.out.println("发射第1发炮弹* * * *");
  System.out.println("发射第2发炮弹* * * *");
  System.out.println("发射第3发炮弹* * * *");
  System.out.println("发射第4发炮弹* * * *");
  System.out.println("发射第5发炮弹* * * *");
  System.out.println("发射5发炮弹结束");
}

public static void main(String[] args) {
    System.out.println("游戏开始...");
    System.out.println("看到了一个怪物...血牙野猪...");
    //调用方法,发射炮弹
    fire();
    System.out.println("...血牙野猪被打倒...");
}

方法名();

修饰符 返回值类型 方法名(参数列表){
  //代码省略...
  return 结果;
}

public class MethodDemo01 {
    public static void main(String[] args) {
        //调用方法printHelloWorld打印10次HelloWorld
        printHelloWorld();
    }
    public static void printHelloWorld() {      
        for (int i = 0; i < 10; i++) {
            System.out.println("HelloWorld");
        }
    }
}

public class MethodDemo02 {
    public static void main(String[] args) {
        //调用方法printHelloWorld，传递整数
        printHelloWorld();
    }
    /*
      定义打印HelloWorld方法
      返回值类型，计算没有结果 void
      参数：不确定打印几次
    */
    public static void printHelloWorld(int n) {       
        for (int i = 0; i < n; i++) {
            System.out.println("HelloWorld");
        }
    }
}

public class MethodDemo03 {
    public static void main(String[] args) {
        // 调用方法getSum，传递两个整数，这里传递的实际数据又称为实际参数       
        // 并接收方法计算后的结果，返回值    
        int sum = getSum(5, 6);
        System.out.println(sum);
    }
    /*
      定义计算两个整数和的方法
      返回值类型，计算结果是int
      参数：不确定数据求和，定义int参数.参数又称为形式参数
    */
    public static int getSum(int a, int b) {
        return a + b;
    }
}

public class MethodDemo04 {
    public static void main(String[] args) {
        //调用方法compare，传递两个整数
        //并接收方法计算后的结果，布尔值
        boolean bool = compare(3, 8);
        System.out.println(bool);
    }
    /*
      定义比较两个整数是否相同的方法
      返回值类型，比较的结果布尔类型
      参数：不确定参与比较的两个整数
    */
    public static boolean compare(int a, int b) {      
        if (a == b) {
            return true;
        } else {
            return false;
        }
    }
}

public class MethodDemo05 {
    public static void main(String[] args) {       
        //调用方法getSum
        //并接收方法计算后的结果，整数
        int sum = getSum();
        System.out.println(sum);
    }
    /*
      定义计算1~100的求和方法
      返回值类型，计算结果整数int
      参数：没有不确定数据
    */
    public static int getSum() {
        //定义变量保存求和
        int sum = 0;
        //从1开始循环，到100结束
        for (int i = 1; i <= 100; i++) {          
            sum = sum + i;
        }
        return sum;
    }
}

public static void kk() {
  int  i; // 局部变量没有默认值
  System.out.println(i);
}

public static void main(String[] args) {
    // 错误，不能输出语句调用void类型方法
    System.out.println(printHello());
}
public static void printHello() {
    System.out.println("Hello");
}

指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。

参数列表：个数不同，数据类型不同，顺序不同。
重载方法调用：JVM通过方法的参数列表，调用不同的方法。

/**
 * 方法的重载
 * 在一个类中，方法名相同，参数列表不同，与修饰符和返回值类型无关，这样的情况称之为方法重载
 */
public class MethodTest1 {
    // 在一个类中，能不能有两个方法名相同的方法  答案：能
    // 但是有要求，方法名相同，参数列表不同
    public static void main(String[] args) {
        //调用方法
        System.out.println(compare(10, 20));
        System.out.println(compare((byte) 10, (byte) 20));
        System.out.println(compare((short) 10, (short) 20));
        System.out.println(compare(10L, 20L));
    }
    //int
    public static boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }
    //byte
    public static boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }
    //short
    public static boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }
    //long
    public static boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }
}

public static void open(){}
public static void open(int a){}
public static void open(int a,int b){}
public static void open(double a,int b){}
public static void open(int a,double b){}
public void open(int i,double d){}
public static void OPEN(){}
public static void open(int i,int j){}

public class MethodTest2 {
    public static void println(byte a) {
        System.out.println(a);
    }
    public static void println(short a) {
        System.out.println(a);
    }
    public static void println(int a) {
        System.out.println(a);
    }
    public static void println(long a) {
        System.out.println(a);
    }
    public static void println(float a) {
        System.out.println(a);
    }
    public static void println(double a) {       
        System.out.println(a);
    }
    public static void println(char a) {
        System.out.println(a);
    }
    public static void println(boolean a) {      
        System.out.println(a);
    }
    public static void println(String a) {       
        System.out.println(a);
    }
}

public class ArgsDemo01 {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前：" + number); //100
        change(number);
        System.out.println("调用change方法后：" + number); //100
    }
    public static void change(int number) {
        number = 200;
    }
}

public class ArgsDemo02 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};
        System.out.println("调用change方法前：" + arr[1]); //100
        change(arr);
        System.out.println("调用change方法后：" + arr[1]); //200
    }
    public static void change(int[] arr) {
        arr[1] = 200;
    }
}

public class MethodTest3 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {11, 22, 33, 44, 55};
        //调用方法
        printArray(arr);
    }
    // 定义一个方法，用数组遍历通用格式对数组进行遍历
    /*
      两个明确：
      返回值类型：void
      参数：int[] arr
    */
    public static void printArray(int[] arr) {
        System.out.print("[");
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x]+", ");
            }
        }
        System.out.println("]");
    }
}

public class MethodTest02 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {12, 45, 98, 73, 60};
        //调用获取最大值方法，用变量接收返回结果
        int number = getMax(arr);
        //把结果输出在控制台
        System.out.println("number:" + number);
    }
    //定义一个方法，用来获取数组中的最大值
    /*
      两个明确：
      返回值类型：int
      参数：int[] arr
    */
    public static int getMax(int[] arr) {
        int max = arr[0];
        for(int x=1; x<arr.length; x++) {
            if(arr[x] > max) {
                max = arr[x];
            }
        }
        return max;
    }
}

做事情 首先第一想到的是对象,那个对象能帮我们做事情
    有对象: 直接用
    没有对象: 我们自己造对象在进行使用

private 数据类型 变量名 ；

public class Student {
  private String name;
  private int age;
}

public class Student {
    private String name;
    private int age;
    public void setName(String n) { 
        name = n;
    }
    public String getName() {
        return name;
    }
    public void setAge(int a) {
        age = a;
    }
    public int getAge() {
        return age;
    }
}

public class Student {
    private String name;
    private int age;
    public void setName(String name) {  
        name = name;
    }
    public void setAge(int age) {
        age = age;
    }
}

this.成员变量名；

public class Student {
    private String name;
    private int age;
    public void setName(String name) {    //name = name;
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        //age = age;
        this.age = age;
    }
    public int getAge() {
        return age;
    }
}

修饰符 构造方法名(参数列表){
  // 方法体
}

public class Student {
    private String name;
    private int age;
    // 无参数构造方法
    public Student() {}
    // 有参数构造方法
    public Student(String name,int age) {   
        this.name = name;
        this.age = age;
    }
}

public class ClassName{ 
  //成员变量
  //构造方法
    //无参构造方法【必须】 
    //有参构造方法【建议】 
  //成员方法   
    //getXxx()
    //setXxx()
}

public class Student {
    //成员变量
    private String name;
    private int age;
    //构造方法，这里用到了方法重载
    public Student() {}
    public Student(String name,int age) {   
        this.name = name;
        this.age = age;
    }
    //成员方法
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    publicvoid setAge(int age) {
        this.age = age;
    }
    publicint getAge() {
        return age;
    }
}

public class TestStudent {
    public static void main(String[] args) {
        //无参构造使用
        Student s= new Student();
        s.setName("柳岩");
        s.setAge(18);
        System.out.println(s.getName()+"‐‐‐"+s.getAge());
        //带参构造使用
        Student s2= new Student("赵丽颖",18);
        System.out.println(s2.getName()+"‐‐‐"+s2.getAge());  }
}

class 父类 { ... }
class 子类 extends 父类 { ... }

/** 定义员工类Employee，做为父类
 */
class Employee {
    String name; // 定义name属性
    // 定义员工的工作方法
    public void work() {
        System.out.println("尽心尽力地工作");    }
}

/*
 * 定义讲师类Teacher 继承 员工类Employee
 */
class Teacher extends Employee {
    // 定义一个打印name的方法
    public void printName() {
        System.out.println("name=" + name);    }
}

/*
 * 定义测试类
 */
public class ExtendDemo01 {
    public static void main(String[] args) {      
        // 创建一个讲师类对象
        Teacher t = new Teacher();
        // 为该员工类的name属性进行赋值
        t.name = "小明";
        // 调用该员工的printName()方法
        t.printName(); // name = 小明
        // 调用Teacher类继承来的work()方法
        t.work();  // 尽心尽力地工作
    }
}

修饰符 abstract 返回值类型 方法名 (参数列表)；

public abstract void run();

public abstract class 类名字 {  
}

public abstract class Animal {
  public abstract void run();
}

public abstract class Animal {
    public abstract void run();
}
public class Cat extends Animal {
    public void run (){
        System.out.println("小猫在墙头走~~~")；         }
}
public class CatTest {
    public static void main(String[] args) {
        // 创建子类对象
        Cat c = new Cat();
        // 调用run方法
        c.run();
    }
}

public interface 接口名 {}

public class 类名 implements 接口名 {}

public interface Inter {
    public int num = 10;
    public final int num2 = 20;
    // public static final int num3 = 30;
    int num3 = 30;

    //public Inter() {}

    //public void show() {}

    public abstract void method();
    void show();
}

public class InterImpl implements Inter {
    public InterImpl() {
        super();
    }
    @Override
    public void method() {
        System.out.println("method");
    }
    @Override
    public void show() {
        System.out.println("show");
    }
}

public class InterfaceDemo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        //    i.num = 20;
        System.out.println(i.num);
        //    i.num2 = 40;
        System.out.println(i.num2);
        System.out.println(Inter.num);
    }
}

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {   
  // 重写接口中抽象方法【必须】
  // 重写接口中默认方法【不重名时可选】
}

interface A {
  public abstract void showA();  
  public abstract void show();
}
interface B {
  public abstract void showB();  
  public abstract void show();
}

public class Fu{}

public class C extends Fu implements A,B{
    @Override
    public void showA() {
        System.out.println("showA");    }
    @Override
    public void showB() {
        System.out.println("showB");    }
    @Override
    public void show() {
        System.out.println("show");    }
}

interface A {
  public void method1();
}
interface B {
  public void method2();
}

interface D extends A,B{
  public void method2();
}

public abstract class Animal {
    private String name;
    private int age;
    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
}

public interface Jumpping {
  public abstract void jump();
}

public class Cat extends Animal implements Jumpping {
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.setName("加菲");
        c.setAge(5);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
    }
}

父类 对象 = new 子类();  // 创建子类对象，存储在父类类型的变量中

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

接口 对象名 = new 接口实现类();

public class Animal {
    public int age = 40;
    public void eat() {
        System.out.println("动物吃东西");
    }
}

public class Cat extends Animal {
    public int age = 20;
    public int weight = 10;
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
        System.out.println(a.age);
        // System.out.println(a.weight);
        a.eat();
        // a.playGame();
    }
}

package day4;

import java.util.Scanner;

//抽象父类
abstract class Person{
   public abstract void eat();
}

//学生类
class Student extends Person{
    @Override
    public void eat() {
        System.out.println("学生吃东西");
    }

    public void kk(){
        System.out.println("kk...");
    }
}

//工人类
class Worker extends Person{
    @Override
    public void eat() {
        System.out.println("工人吃东西");
    }
}

class Driver extends Person{
    @Override
    public void eat() {
        System.out.println("司机吃东西");
    }
}

public class Demo4 {
    public static void main(String[] args) {
        System.out.println("请输入你身份");
        Scanner in = new Scanner(System.in);
        int i = in.nextInt();
        //父类类型  变量名  = new 子类实例();
        Person person = null;
        if(i == 1){
            person = new Student();
        }else if(i == 2){
            person = new Worker();
        }else if(i == 3){
            person = new Driver();
        }
        m1(person);
    }

    public static void init(){
        System.out.println("初始化系统");
    }

    public static void go(){
        System.out.println("系统继续运行...");
    }

    public static void m1(Person person){
        init();
        person.eat();
        go();
    }


}

package day4;

import java.util.Scanner;

public class Demo5 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int j = in.nextInt();
        Person person = m1(j);
        if(person instanceof  Student){
            Student s = (Student) person;
            s.kk();
        }else if(person instanceof Worker){

        }
    }

    public static Person m1(int i){
        Person person = null;
        if(i == 1){
            person = new Worker();
        }else if(i == 2){
            person = new Student();
        }else if(i == 3){
            person = new Driver();
        }
        return person;
    }

    /*public static Worker m1(){
        return new Worker();
    }

    public static Student m2(){
        return new Student();
    }

    public static Driver m3(){
        return new Driver();
    }*/

}

package day4;

public class Demo6 {
    public static void main(String[] args) {
        //用普通的方式new对象，和用多态的方式new对象，有啥区别?
        //用多态的方式new对象，只能调用子类中继承或者重写的方法,而不能调用子类中独有方法

        Student s1 = new Student();
        s1.eat();
        s1.kk();

        Person p1 = new Student();

        //p1不能调用kk方法，其实原因是p1可以存储Person任意子类对象，并不能确定是哪个子类，
        // 所以不让调用子类特有的方法
        //如果现在确定p1存储的是Student对象,可以通过强制类型转换，然后再调用kk方法
        //p1.kk();

        if(p1 instanceof  Student){  //判断p1中存储的对象是否是Student类型
            //如果p1里面存储的对象是Student类型，则执行if中的代码
            //将p1强制类型转换成Student对象,然后就可以通过转换后的对象调用Student独有的方法
            Student s2 = (Student)p1;
            s2.kk();
        }

    }
}

public abstract class Animal {     
  public abstract void eat();
} 

class Cat extends Animal { 
    public void eat() { 
        System.out.println("吃鱼"); 
    } 
} 
class Dog extends Animal { 
    public void eat() { 
        System.out.println("吃骨头");      } 
}

public class Test {
    public static void main(String[] args) {        // 多态形式，创建对象
        Cat c = new Cat(); 
        Dog d = new Dog();
        // 调用showCatEat
        showCatEat(c);
        // 调用showDogEat
        showDogEat(d);
        /*
          以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代       
          而执行效果一致
        */
        showAnimalEat(c);
        showAnimalEat(d);
    }
    public static void showCatEat (Cat c){
        c.eat();
    }
    public static void showDogEat (Dog d){
        d.eat();
    }
    public static void showAnimalEat (Animal a){
        a.eat();
    }
}

父类类型  变量名 = new 子类类型();
如：Animal a = new Cat();

子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a; 

abstract class Animal { 
    abstract void eat(); 
} 
class Cat extends Animal { 
    public void eat() { 
        System.out.println("吃鱼"); 
    } 
    public void catchMouse() { 
        System.out.println("抓老鼠");      } 
} 
class Dog extends Animal { 
    public void eat() { 
        System.out.println("吃骨头");      } 
    public void watchHouse() { 
        System.out.println("看家"); 
    } 
}

public class Test {
    public static void main(String[] args) {
        // 向上转型 
        Animal a = new Cat(); 
        a.eat();                // 调用的是 Cat 的 eat
        // 向下转型 
        Cat c = (Cat)a;      
        c.catchMouse();         // 调用的是 Cat 的 catchMouse
    }
} 

 public class Test {
    public static void main(String[] args) {
        // 向上转型 
        Animal a = new Cat(); 
        a.eat();               // 调用的是 Cat 的 eat
        // 向下转型 
        Dog d = (Dog)a;      
        d.watchHouse();        // 调用的是 Dog 的 watchHouse 【运行报错】    } 
}

变量名 instanceof 数据类型
  如果变量属于该数据类型，返回true。
  如果变量不属于该数据类型，返回false。

public class Test {
    public static void main(String[] args) {
        // 向上转型 
        Animal a = new Cat(); 
        a.eat();               // 调用的是 Cat 的 eat
        // 向下转型 
        if (a instanceof Cat){
            Cat c = (Cat)a;      
            c.catchMouse();        // 调用的是 Cat 的 catchMouse

        } else if (a instanceof Dog){
            Dog d = (Dog)a;      
            d.watchHouse();       // 调用的是 Dog 的 watchHouse
        }
    } 
}

public abstract class Person {
    private String name;
    private int age;
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
}

public abstract class Player extends Person {
    public Player() {
    }
    public Player(String name, int age) {
        super(name, age); //调用父类的有参构造方法
    }
    public abstract void study();
}

public abstract class Coach extends Person {
    public Coach() {
    }
    public Coach(String name, int age) {
        super(name, age);
    }
    public abstract void teach();
}

public interface SpeakEnglish {
  public abstract void speak();
}

public class BasketballCoach extends Coach {
    public BasketballCoach() {
    }
    public BasketballCoach(String name, int age) {
        super(name, age);
    }
    @Override
    public void teach() {
        System.out.println("篮球教练教如何运球和投篮");
    }
    @Override
    public void eat() {
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }
}

public class PingPangCoach extends Coach implements
                                             SpeakEnglish {
    public PingPangCoach() {
    }
    public PingPangCoach(String name, int age) {
        super(name, age);
    }
    @Override
    public void teach() {
        System.out.println("乒乓球教练教如何发球和接球");
    }
    @Override
    public void eat() {
        System.out.println("乒乓球教练吃小白菜，喝大米粥");
    }
    @Override
    public void speak() {
        System.out.println("乒乓球教练说英语");
    }
}

public class PingPangPlayer extends Player implements
                                               SpeakEnglish {
    public PingPangPlayer() {
    }
    public PingPangPlayer(String name, int age) {
        super(name, age);
    }
    @Override
    public void study() {
        System.out.println("乒乓球运动员学习如何发球和接球");
    }
    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃大白菜，喝小米粥");
    }
    @Override
    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }
}

public class BasketballPlayer extends Player {
    public BasketballPlayer() {
    }
    public BasketballPlayer(String name, int age) {
        super(name, age);
    }
    @Override
    public void study() {
        System.out.println("篮球运动员学习如何运球和投篮");
    }
    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉，喝牛奶");
    }
}

class 外部类 {
  class 内部类{
 }
}

外部类名.内部类名 对象名 = new 外部类型().new 内部类型();

public class Person {
    private  boolean live = true;
    class Heart {
        public void jump() {
            // 直接访问外部类成员
            if (live) {
                System.out.println("心脏在跳动");           
            }else {
                System.out.println("心脏不跳了");           
            }
        }
    }
    public boolean isLive() {
        return live;
    }
    public void setLive(boolean live) {
        this.live = live;
    }
}

public class InnerDemo {
    public static void main(String[] args) {      
        // 创建外部类对象
        Person p  = new Person();
        // 创建内部类对象
        Heart heart = p.new Heart();
        // 调用内部类方法
        heart.jump();
        // 调用外部类方法
        p.setLive(false);
        // 调用内部类方法
        heart.jump();
    }
}

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}
public class Outer {
    public void show(){
        // 局部内部类
        class Inner{
            public void method(){
                System.out.println("Inner 局部内部类的method方法执行了....");
            }
        }
        // 在外部类的方法内使用局部内部类
        Inner inner = new Inner();
        inner.method();
    }
}

1. 定义子类
2. 重写接口中的方法
3. 创建子类对象
4. 调用重写后的方法

new 父类名或者接口名(){
    // 方法重写
    @Override
    public void method() {        // 执行语句
    }
};

public interface FlyAble{
  public abstract void fly();
}

public class InnerDemo {
    public static void main(String[] args) {
        /*
          1.等号右边:是匿名内部类，定义并创建该接口的子类对象      
          2.等号左边:是多态赋值,接口类型引用指向子类对象
        */
        FlyAble  f = new FlyAble(){
                public void fly() {
                    System.out.println("我飞了~~~");
                }
            };
        //调用 fly方法,执行重写后的方法
        f.fly();
    }
}

public class InnerDemo2 {
    public static void main(String[] args) {
        /*
          1.等号右边:定义并创建该接口的子类对象
          2.等号左边:是多态,接口类型引用指向子类对象       */
        FlyAble  f = new FlyAble(){
                public void fly() {
                    System.out.println("我飞了~~~");            }
            };
        // 将f传递给showFly方法中
        showFly(f);
    }
    public static void showFly(FlyAble f) {
        f.fly();
    }
}

public class InnerDemo3 {
    public static void main(String[] args) {                
        /*
          创建匿名内部类,直接传递给showFly(FlyAble f)
        */
        showFly( new FlyAble(){
                public void fly() {
                    System.out.println("我飞了~~~");
                }
            });
    }
    public static void showFly(FlyAble f) {
        f.fly();
    }
}

public class Student {
  // 属性
  private String name;
  private int age;
  // 构造方法
  // setter 和 getter方法
}

public class Test {
    public static void main(String[] args) {
        Student stu = new Student("张三", 13);
        System.out.println(stu);
        useStudent(stu);
        System.out.println("~~~~~~~~~~~~~~~~~~~");
        Student student = getStudent();
        System.out.println(student);
        student.show();
    }
    /**
       类名作为方法的返回值和参数,要的是该类型的对象
    */
    public static void useStudent(Student student) {
        System.out.println(student);
        student.show();
    }
    public static Student getStudent() {
        // 创建学生并返回
        Student stu = new Student("李四", 14);
        System.out.println(stu);
        return stu;
    }
}

abstract class Animal {
    public abstract void eat();
}
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        useAnimal(a);
        Animal a2 = getAnimal(); //new Cat()
        a2.eat();
    }
    public static void useAnimal(Animal a) { //Animal a = newCat();
        a.eat();
    }
    public static Animal getAnimal() {
        Animal a = new Cat();
        return a;
    }
}

interface Jumpping {
    void jump();
}
class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
public class JumppingDemo {
    public static void main(String[] args) {
        Jumpping j = new Cat();
        useJumpping(j);
        Jumpping j2 = getJumpping(); //new Cat()
        j2.jump();
    }
    public static void useJumpping(Jumpping j) { //Jumpping j= new Cat();
        j.jump();
    }
    public static Jumpping getJumpping() {
        Jumpping j = new Cat();
        return j;
    }
}

final：不可改变。可以用于修饰类、方法和变量。

final class 类名 { 
}

修饰符 final 返回值类型 方法名(参数列表){   
  //方法体
}

public class FinalDemo1 {
  public static void main(String[] args) {       
    // 声明变量，使用final修饰
    final int a;
    // 第一次赋值
    a = 10;
    // 第二次赋值
    a = 20; // 报错,不可重新赋值
    // 声明变量，直接赋值，使用final修饰
    final int b = 10;
    // 第二次赋值
    b = 20; // 报错,不可重新赋值
 }
}

public class FinalDemo2 {
    public static void main(String[] args) {
        // 创建 User 对象
        final   User u = new User();
        // 创建 另一个 User对象
        u = new User(); // 报错，指向了新的对象，地址值改变。
        // 调用setName方法
        u.setName("张三"); // 可以修改
    }
}

 public class User {
    final String USERNAME = "张三";   
  private int age;
}

 public class User {
    final String USERNAME ;
    private int age;
    public User(String username, int age) {      
    this.USERNAME = username;
        this.age = age;
    }
}

package 包名; 如果是多级包，中间用"."进行分割

public： 公共的
protected：受保护的
default： 默认的
private： 私有的

static 数据类型 变量名

static int numberID；

类方法：使用 static关键字修饰的成员方法，习惯称为静态方法

修饰符 static 返回值类型 方法名 (参数列表){
  // 执行语句
}

public static void showNum() {
  System.out.println("num:" + numberOfStudent);
}

// 访问类变量
类名.类变量名；
// 调用静态方法
类名.静态方法名(参数)；

public class StuDemo2 {
    public static void main(String[] args) {          // 访问类变量
        System.out.println(Student.numberOfStudent);    // 调用静态方法
        Student.showNum();
    }
}

public class ClassName{
  static {
    // 执行语句
 }
}

public class Game {
    public static int number;
    public static String name;
    static {
        // 给类变量赋值
        number = 2;
        name = "张三";
    }
}

public class MyClass /*extends Object*/ {
    // ...
}

public static boolean equals(Object a, Object b) {  
  return (a == b) || (a != null && a.equals(b));
}

public class String_Demo01 {
    public static void main(String[] args) {
        // 创建字符串对象
        String s1 = "hello";
        String s2 = "hello";
        String s3 = "HELLO";
        // boolean equals(Object obj):比较字符串的内容是否相同
        System.out.println(s1.equals(s2)); // true
        System.out.println(s1.equals(s3)); // false
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
        //boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写   
        System.out.println(s1.equalsIgnoreCase(s2)); // true
        System.out.println(s1.equalsIgnoreCase(s3)); // true
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐")q
    }
}

public class String_Demo02 {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "helloworld";
        // int length():获取字符串的长度，其实也就是字符个数
        System.out.println(s.length());
        System.out.println("‐‐‐‐‐‐‐‐");
        // String concat (String str):将将指定的字符串连接到该字符串的末尾.   
        String s = "helloworld";
        String s2 = s.concat("**hello itfxp");
        System.out.println(s2);// helloworld**hello itfxp
        // char charAt(int index):获取指定索引处的字符
        System.out.println(s.charAt(0));
        System.out.println(s.charAt(1));
        System.out.println("‐‐‐‐‐‐‐‐");
        // int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1
        System.out.println(s.indexOf("l"));
        System.out.println(s.indexOf("owo"));
        System.out.println(s.indexOf("ak"));
        System.out.println("‐‐‐‐‐‐‐‐");
        // String substring(int start):从start开始截取字符串到字符串结尾
        System.out.println(s.substring(0));
        System.out.println(s.substring(5));
        System.out.println("‐‐‐‐‐‐‐‐");
        // String substring(int start,int end):从start到end截取字符串。含start，不含end。   
        System.out.println(s.substring(0, s.length()));
        System.out.println(s.substring(3,8));
    }
}

public class String_Demo03 {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "abcde";
        // char[] toCharArray():把字符串转换为字符数组    char[] chs = s.toCharArray();
        for(int x = 0; x < chs.length; x++) {
            System.out.println(chs[x]);
        }
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
        // byte[] getBytes ():把字符串转换为字节数组
        byte[] bytes = s.getBytes();
        for (byte aByte : bytes) {
            System.out.println(aByte);
        }
        for(int x = 0; x < bytes.length; x++) {
            System.out.println(bytes[x]);
        }

        System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
        // 替换字母it为大写IT
        String str = "itfxp itnum";
        String replace = str.replace("it", "IT");
        System.out.println(replace); // ITfxp ITnum
    }
}

public class String_Demo03 {
    public static void main(String[] args) {
        //创建字符串对象
        String s = "aa|bb|cc";

        String[] strArray = s.split("|"); // ["aa","bb","cc"]  
        for(int x = 0; x < strArray.length; x++) {
            System.out.println(strArray[x]); // aa bb cc
        }
    }
}

public class StringTest1 {
  public static void main(String[] args) {
    //定义一个int类型的数组
    int[] arr = {1, 2, 3};
    //调用方法
    String s = arrayToString(arr);
    //输出结果
    System.out.println("s:" + s);
 }
  /*
     * 写方法实现把数组中的元素按照指定的格式拼接成一个字符串   
     * 两个明确：
     * 返回值类型：String
     * 参数列表：int[] arr
     */
  public static String arrayToString(int[] arr) {
    // 创建字符串s
    String s = new String("[");
    // 遍历数组，并拼接字符串
    for (int x = 0; x < arr.length; x++) {    
      if (x == arr.length ‐ 1) {
        s = s.concat(arr[x] + "]");
     } else {
        s = s.concat(arr[x] + ",");
     }
   }
    return s;
 }
}

package day6;

public class Demo7 {
    public static void main(String[] args) {
        // 定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串。格式如下：[1,2,3]
        int[] arr = {1,2,3};

        String str = "["+arr[0]+","+arr[1]+","+arr[2]+"]";
        System.out.println(str);
    }
}

public class StringTest2 {
    public static void main(String[] args) {
        //键盘录入一个字符串数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串数据：");
        String s = sc.nextLine();
        //定义三个统计变量，初始化值都是0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        //遍历字符串，得到每一个字符
        for(int x=0; x<s.length(); x++) {
            char ch = s.charAt(x);
            //拿字符进行判断
            if(ch>='A'&&ch<='Z') {
                bigCount++;
            }else if(ch>='a'&&ch<='z') {
                smallCount++;
            }else if(ch>='0'&&ch<='9') {
                numberCount++;
            }else {
                System.out.println("该字符"+ch+"非法");
            }
        }
        //输出结果
        System.out.println("大写字符："+bigCount+"个");
        System.out.println("小写字符："+smallCount+"个");
        System.out.println("数字字符："+numberCount+"个");  }
}

public class Demo10 {
    public static void main(String[] args) {
        long t1 = System.currentTimeMillis();
        System.out.println(t1);
    }
}