Java SE

格式: 数据类型  变量名;

//例如：
//存储一个整数类型的年龄
int age; 

//存储一个小数类型的体重
double weight;

//存储一个单字符类型的性别 
char gender;

//存储一个布尔类型的婚姻状态
boolean marry;

//存储一个字符串类型的姓名
String name;

//声明多个同类型的变量
int a,b,c; //表示a,b,c三个变量都是int类型。

变量名 = 值;

age = 18;
weight = 109;
gender = '女';

int m = 1;
int n = m;
        
int x = 1;
int y = 2;
int z = 2 * x + y;

//先声明，后初始化
char gender;
gender = '女';

//给变量重新赋值，修改gender变量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男

boolean isBeauty = true;
String name = "迪丽热巴";

System.out.println("" + 1 + 2);//12
 
int num = 10;
boolean b1 = true;
String s1 = "abc";

String s2 = s1 + num + b1;
System.out.println(s2);//abc10true

//String s3 = num + b1 + s1;//编译不通过，因为int类型不能与boolean运算
String s4 = num + (b1 + s1);//编译通过

String str = "123";
int num = (int)str;//错误的

int num = Integer.parseInt(str);//正确的，后面才能讲到，借助包装类的方法才能转

(条件表达式)? 表达式1:表达式2

if(条件表达式)｛
          语句块;
｝

if(条件表达式) { 
     语句块1;
 }else {
     语句块2;
 }

if (条件表达式1) {
     语句块1;
 } else if (条件表达式2) {
     语句块2;
 }
 ...
 }else if (条件表达式n) {
     语句块n;
 } else {
     语句块n+1;
 }

switch(表达式){
     case 常量值1:
         语句块1;
         //break;
     case 常量值2:
         语句块2;
         //break; 
     // ...
    [default:
         语句块n+1;
         break;
    ]
 }

for (①初始化部分; ②循环条件部分; ④迭代部分)｛
             ③循环体部分;
 ｝

①初始化部分
 while(②循环条件部分)｛
     ③循环体部分;
     ④迭代部分;
 }

①初始化部分;
 do{
     ③循环体部分
     ④迭代部分
 }while(②循环条件部分);

//推荐
 元素的数据类型[] 一维数组的名称;
 
 //不推荐
 元素的数据类型  一维数组名[];

int[] arr;
int arr1[];
double[] arr2;
String[] arr3;  //引用类型变量数组

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

int[] arr = new int[]{1,2,3,4,5};//正确
//或
int[] arr;
arr = new int[]{1,2,3,4,5};//正确

int[] arr = {1,2,3,4,5};//正确
 
int[] arr;
arr = {1,2,3,4,5};//错误

public class ArrayTest2 {
     public static void main(String[] args) {
         int[] arr = {1,2,3,4,5};//右边不需要写new int[]
 
         int[] nums;
         nums = new int[]{10,20,30,40}; //声明和初始化在两个语句完成，就不能使用new int[]
 
         char[] word = {'h','e','l','l','o'};
 
         String[] heros = {"袁隆平","邓稼先","钱学森"};
 
         System.out.println("arr数组：" + arr);//arr数组：[I@1b6d3586
         System.out.println("nums数组：" + nums);//nums数组：[I@4554617c
         System.out.println("word数组：" + word);//word数组：[C@74a14482
         System.out.println("heros数组：" + heros);//heros数组：[Ljava.lang.String;@1540e19d
     }
 }

数组存储的元素的数据类型[] 数组名字 = new 数组存储的元素的数据类型[长度];
 
或

数组存储的数据类型[] 数组名字;
数组名字 = new 数组存储的数据类型[长度];

int[] arr = new int[5];
 
int[] arr;
arr = new int[5];

public class ArrayTest6 {
    public static void main(String argv[]){
        int a[]= new int[5]; 
        System.out.println(a[3]); //a[3]的默认值为0
    }
}

public static void main(String[] args) {
    // 定义数组，存储3个元素
    int[] arr = new int[3];
    //数组索引进行赋值
    arr[0] = 5;
    arr[1] = 6;
    arr[2] = 7;
    //输出3个索引上的元素值
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    //定义数组变量arr2，将arr的地址赋值给arr2
    int[] arr2 = arr;
    arr2[1] = 9;
    System.out.println(arr[1]);
}

//推荐
 元素的数据类型[][] 二维数组的名称;
 
//不推荐
元素的数据类型  二维数组名[][];
//不推荐
元素的数据类型[]  二维数组名[];

public class Test20TwoDimensionalArrayDefine {
    public static void main(String[] args) {
        //存储多组成绩
        int[][] grades;

        //存储多组姓名
        String[][] names;
    }
}

//（1）确定行数和列数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[m][n];
 //其中，m:表示这个二维数组有多少个一维数组。或者说一共二维表有几行
 //其中，n:表示每一个一维数组的元素有多少个。或者说每一行共有一个单元格
 
//此时创建完数组，行数、列数确定，而且元素也都有默认值

//（2）再为元素赋新值
二维数组名[行下标][列下标] = 值;

//（1）先确定总行数
 元素的数据类型[][] 二维数组名 = new 元素的数据类型[总行数][];
 
 //此时只是确定了总行数，每一行里面现在是null
 
 //（2）再确定每一行的列数，创建每一行的一维数组
 二维数组名[行下标] = new 元素的数据类型[该行的总列数];
 
 //此时已经new完的行的元素就有默认值了，没有new的行还是null
 
 //(3)再为元素赋值
 二维数组名[行下标][列下标] = 值;

for(int i=0; i<二维数组名.length; i++){ //二维数组对象.length
    for(int j=0; j<二维数组名[i].length; j++){//二维数组行对象.length
        System.out.print(二维数组名[i][j]);
    }
    System.out.println();
}

int[][] arr = {
    {1},
    {2,2},
    {3,3,3},
    {4,4,4,4},
    {5,5,5,5,5}
};

//1、声明二维数组，并确定行数和列数
int[][] arr = new int[4][5];

//2、确定元素的值
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr.length; j++) {
        arr[i][j] = i + 1;
    }
}

//1、声明一个二维数组，并且确定行数
//因为每一行的列数不同，这里无法直接确定列数
int[][]  arr = new int[5][];

//2、确定每一行的列数
for(int i=0; i<arr.length; i++){
    /*
                        arr[0] 的列数是1
                        arr[1] 的列数是2
                        arr[2] 的列数是3
                        arr[3] 的列数是4
                        arr[4] 的列数是5
                        */
    arr[i] = new int[i+1];
}

//3、确定元素的值
for(int i=0; i<arr.length; i++){
    for(int j=0; j<arr[i].length; j++){
        arr[i][j] = i+1;
    }
}

public class TestArrayReverse1 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        System.out.println("反转之前：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        //反转
         /*
        思路：首尾对应位置的元素交换
        （1）确定交换几次
           次数 = 数组.length / 2
        （2）谁和谁交换
        for(int i=0; i<次数; i++){
             int temp = arr[i];
             arr[i] = arr[arr.length-1-i];
             arr[arr.length-1-i] = temp;
        }
         */
        for(int i=0; i<arr.length/2; i++){
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }

        System.out.println("反转之后：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

}

public class ArrTest1 {
    public static void main(String[] args) {

        int[] arr = new int[]{1,2,3,4,5};
        int[] newArr = new int[arr.length << 1];

        for(int i = 0;i < arr.length;i++){
            newArr[i] = arr[i];
        }

        newArr[arr.length] = 10;
        newArr[arr.length + 1] = 20;
        newArr[arr.length + 2] = 30;

        arr = newArr;

        //遍历arr
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

public class ArrTest2 {
    public static void main(String[] args) {

        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        //删除数组中索引为4的元素
        int delIndex = 4;
        //方案1：
        /*//创建新数组
        int[] newArr = new int[arr.length - 1];

        for (int i = 0; i < delIndex; i++) {
            newArr[i] = arr[i];
        }
        for (int i = delIndex + 1; i < arr.length; i++) {
            newArr[i - 1] = arr[i];
        }

        arr = newArr;
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }*/

        //方案2：
        for (int i = delIndex; i < arr.length - 1; i++) {
            arr[i] = arr[i + 1];
        }
        arr[arr.length - 1] = 0;

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

public class TestArrayOrderSearch {
    //查找value第一次在数组中出现的index
    public static void main(String[] args){
        int[] arr = {4,5,6,1,9};
        int value = 1;
        int index = -1;

        for(int i=0; i<arr.length; i++){
            if(arr[i] == value){
                index = i;
                break;
            }
        }

        if(index==-1){
            System.out.println(value + "不存在");
        }else{
            System.out.println(value + "的下标是" + index);
        }
    }
}

//二分法查找：要求此数组必须是有序的。
int[] arr3 = new int[]{-99,-54,-2,0,2,33,43,256,999};
boolean isFlag = true;
int value = 256;
//int value = 25;
int head = 0;//首索引位置
int end = arr3.length - 1;//尾索引位置
while(head <= end){
    int middle = (head + end) / 2;
    if(arr3[middle] == value){
        System.out.println("找到指定的元素，索引为：" + middle);
        isFlag = false;
        break;
    }else if(arr3[middle] > value){
        end = middle - 1;
    }else{//arr3[middle] < value
        head = middle + 1;
    }
}

if(isFlag){
    System.out.println("未找打指定的元素");
}

/*
1、冒泡排序（最经典）
思想：每一次比较“相邻（位置相邻）”元素，如果它们不符合目标顺序（例如：从小到大），
     就交换它们，经过多轮比较，最终实现排序。
         （例如：从小到大）         每一轮可以把最大的沉底，或最小的冒顶。
         
过程：arr{6,9,2,9,1}  目标：从小到大

第一轮：
        第1次，arr[0]与arr[1]，6>9不成立，满足目标要求，不交换
        第2次，arr[1]与arr[2]，9>2成立，不满足目标要求，交换arr[1]与arr[2] {6,2,9,9,1}
        第3次，arr[2]与arr[3]，9>9不成立，满足目标要求，不交换
        第4次，arr[3]与arr[4]，9>1成立，不满足目标要求，交换arr[3]与arr[4] {6,2,9,1,9}
        第一轮所有元素{6,9,2,9,1}已经都参与了比较，结束。
        第一轮的结果：第“一”最大值9沉底（本次是后面的9沉底），即到{6,2,9,1,9}元素的最右边

第二轮：
        第1次，arr[0]与arr[1]，6>2成立，不满足目标要求，交换arr[0]与arr[1] {2,6,9,1,9}
        第2次，arr[1]与arr[2]，6>9不成立，满足目标要求，不交换
        第3次：arr[2]与arr[3]，9>1成立，不满足目标要求，交换arr[2]与arr[3] {2,6,1,9,9}
        第二轮未排序的所有元素 {6,2,9,1}已经都参与了比较，结束。
        第二轮的结果：第“二”最大值9沉底（本次是前面的9沉底），即到{2,6,1,9}元素的最右边
第三轮：
        第1次，arr[0]与arr[1]，2>6不成立，满足目标要求，不交换
        第2次，arr[1]与arr[2]，6>1成立，不满足目标要求，交换arr[1]与arr[2] {2,1,6,9,9}
        第三轮未排序的所有元素{2,6,1}已经都参与了比较，结束。
        第三轮的结果：第三最大值6沉底，即到 {2,1,6}元素的最右边
第四轮：
        第1次，arr[0]与arr[1]，2>1成立，不满足目标要求，交换arr[0]与arr[1] {1,2,6,9,9}
        第四轮未排序的所有元素{2,1}已经都参与了比较，结束。
        第四轮的结果：第四最大值2沉底，即到{1,2}元素的最右边

*/
public class Test19BubbleSort{
    public static void main(String[] args){
        int[] arr = {6,9,2,9,1};

        //目标：从小到大
        //冒泡排序的轮数 = 元素的总个数 - 1
        //轮数是多轮，每一轮比较的次数是多次，需要用到双重循环，即循环嵌套
        //外循环控制 轮数，内循环控制每一轮的比较次数和过程
        for(int i=1; i<arr.length; i++){ //循环次数是arr.length-1次/轮
                        /*
                        假设arr.length=5
                        i=1,第1轮，比较4次
                                arr[0]与arr[1]
                                arr[1]与arr[2]
                                arr[2]与arr[3]
                                arr[3]与arr[4]
                                
                                arr[j]与arr[j+1]，int j=0;j<4; j++
                                
                        i=2,第2轮，比较3次
                                arr[0]与arr[1]
                                arr[1]与arr[2]
                                arr[2]与arr[3]
                                
                                arr[j]与arr[j+1]，int j=0;j<3; j++
                                
                        i=3,第3轮，比较2次
                                arr[0]与arr[1]
                                arr[1]与arr[2]
                                
                                arr[j]与arr[j+1]，int j=0;j<2; j++
                        i=4,第4轮，比较1次
                                arr[0]与arr[1]
                        
                                arr[j]与arr[j+1]，int j=0;j<1; j++
                                
                                int j=0; j<arr.length-i; j++
                        */
            for(int j=0; j<arr.length-i; j++){
                //希望的是arr[j] < arr[j+1]
                if(arr[j] > arr[j+1]){
                    //交换arr[j]与arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        //完成排序，遍历结果
        for(int i=0; i<arr.length; i++){
            System.out.print(arr[i]+"  ");
        }
    }
}

import java.util.Arrays;
public class SortTest {
    public static void main(String[] args) {
        int[] arr = {3, 2, 5, 1, 6};
        System.out.println("排序前" + Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后" + Arrays.toString(arr));
    }
}

public class Student {
  
  //特征：表现为属性，属性有默认值，整型: 0，浮点型: 0.0，布尔型: false
  //字符型: '\0'  '\u000'，引用数据类型: null
        //成员变量
        //姓名
        String name;
        //年龄
        int age;
  
  
        //行为：表现出的是方法
        //成员方法
        public void study() {
                System.out.println("好好学习，天天向上");
        }
        
        public void eat() {
                System.out.println("吃饱了才有力气减肥");
        }
}

public class StudentTest {
        public static void main(String[] args) {
    //创建对象
                //类名  对象名  = new 类名();
                Student s = new Student();
                
                //使用成员变量
                System.out.println("姓名："+s.name);//null
                System.out.println("年龄："+s.age);//0
                System.out.println("----------");
                
                //给成员变量赋值
                s.name = "孙俪";
                s.age = 30;
                //再次使用成员变量
                System.out.println("姓名："+s.name);//孙俪
                System.out.println("年龄："+s.age);//30
                System.out.println("----------");
                
                //调用成员方法
                s.study();
                s.eat();
        }
}

class Person {
    String name;
    static int a;
    
    void eat() {}
    static void sleep() {}
}
class Program {
    public static void main(String[] args) {
        Person xiaomin = new Person();
        // 访问非静态成员
        xiaomin.name = "xiaomin";
        xiaomin.eat();
        // 访问静态成员
        Person.a = 10;
        Person.sleep();
        // 注: 
        // 访问静态的成员, 也可以使用对象来访问, 但是会有警告
        // 推荐使用类来访问静态成员
    }
}

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 StudentTest {
        public static void main(String[] args) {
                //创建对象
                Student s = new Student();
                System.out.println(s.getName()+"***"+s.getAge());
                
                //给成员变量赋值
                s.setName("杨幂");
                s.setAge(30);
                System.out.println(s.getName()+"***"+s.getAge());
        }
}

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

        public void setName(String name) { 
                //name = name;
                this.name = name;
        }

        public String getName() {
                return name;
                //return this.name;
        }

        public void setAge(int age) {
                this.age = age;
        }

        public int getAge() {
                return age;
        }
}

public class StudentTest {
        public static void main(String[] args) {
                // 创建对象
                Student s = new Student();
                System.out.println(s.getName() + "---" + s.getAge());

                s.setName("孙俪");
                s.setAge(30);
                System.out.println(s.getName() + "---" + s.getAge());
        }
}

public class Student {        
        public Student() {
                System.out.println("这是构造方法");
        }
}

public class StudentDemo {
        public static void main(String[] args) {
                //如何调用构造方法呢?
                //通过new关键字调用
                //格式：类名 对象名 = new 构造方法(...);
                Student s = new Student();
        }
}

public class Student {
        private String name;
        private int age;
        
        public Student() {}
        
        public Student(String name) {
                this.name = name;
        }
        
        public Student(int age) {
                this.age = age;
        }
        
        public Student(String name,int age) {
                this.name = name;
                this.age = age;
        }
        
        public void show() {
                System.out.println(name+"---"+age);
        }
}


public class StudentTest {
        public static void main(String[] args) {
                //如何调用构造方法呢?
                //其实通过new关键字就可以
                //格式：类名 对象名 = new 构造方法名(...);
                Student s = new Student();
                s.show();
                
                //public Student(String name)
                Student s2 = new Student("孙俪");
                s2.show();
                
                //public Student(int age)
                Student s3 = new Student(30);
                s3.show();
                
                //public Student(String name,int age)
                Student s4 = new Student("孙俪",30);
                s4.show();
        }
}

public class Person {
        private String name;
        private int age;
        
        public Person() {}

        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 class Student extends Person {
        public void study() {
                System.out.println("学生要学到");
        }
}


public class Teacher extends Person {
        public void teach() {
                System.out.println("老师要讲到");
        }
}

public class Father {
        //为了演示案，这里使用public修饰了成员变量，实际开发中用private
        //年龄
        public int age = 45;
}


public class Son extends Father {
        //身高
        public int height = 170;
        //年龄
        public int age = 20;
        
        public void show() {
                System.out.println(height);
                System.out.println(age);
        }
        
        public void printAge() {
                int age = 10;
                System.out.println(age);
        }
}


public class ExtendsTest {
        public static void main(String[] args) {
                Son s = new Son();
                //s.show();
                s.printAge();
        }
}

public class Father {
        public int age = 45;
}

public class Son extends Father {
        public int age = 20;
        public void printAge() {
            int age = 10;
            System.out.println(age);
            //我要访问子类成员范围的age
            System.out.println(this.age);
            //我要访问父类成员范围的age
            System.out.println(super.age);
        }

}

public class ExtendsTest {
    public static void main(String[] args) {
        Son s = new Son();
        s.printAge();
    }
}

public class Father {
        
        public Father() {
                System.out.println("Father无参构造方法");
        }
        
        
        public Father(String name) {
                System.out.println("Father带参构造方法");
                System.out.println(name);
        }
}

public class Son extends Father {
        public Son() {
                //super();
                super("杨幂");
                System.out.println("Son无参构造方法");
        }
        
        public Son(String name) {
                //super();
                super("杨幂");
                System.out.println("Son带参构造方法");
                System.out.println(name);
        }
}

public class ExtendsTest {
        public static void main(String[] args) {
                Son s = new Son();
                System.out.println("---------");
                Son s2 = new Son("小幂");
        }
}

public class Father {
        public void show() {
                System.out.println("Father show");
        }
}
/*
 * Java继承中成员方法的访问特点：
 *                 A:子类中方法和父类中方法的声明不一样，这个太简单
 *                 B:子类中方法和父类中方法的声明一样，调用的到底是谁的呢?
 *                         执行的是子类中的方法。
 */
public class Son extends Father {
        public void method() {
                System.out.println("Son method");
        }
        
        public void show() {
                System.out.println("Son show");
        }
}

public class ExtendsTest {
        public static void main(String[] args) {
                Son s = new Son();
                s.method();
                s.show();
                //s.function();
        }
}

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

public class NewPhone extends Phone {
        
        public void call(String name) {
                System.out.println("开启视频功能");
                super.call(name);
        }
}
/*
 * 方法重写：子类中出现了和父类中一模一样的方法声明的情况。
 * 
 * 方法重写的应用：
 *                 当子类需要父类的功能，而功能主体子类又有自己的特有内容的时候，就考虑使用方法重写，
 *                 这样即保证了父类的功能，还添加了子类的特有内容。
 */
public class PhoneTest {
        public static void main(String[] args) {
                Phone p = new Phone();
                p.call("孙俪");
                System.out.println("-----------");
                NewPhone np = new NewPhone();
                np.call("孙俪");
        }
}

abstract class 类名 {
}

public abstract 返回值类型 方法名(参数);

//研发工程师 
abstract class Developer {
        public abstract void work();//抽象函数。需要abstract修饰，并分号;结束
}

//JavaEE工程师
class JavaEE extends Developer{
        public void work() {
                System.out.println("正在研发淘宝网站");
        }
}

//移动端工程师
class Android extends Developer {
        public void work() {
                System.out.println("正在研发某款app");
        }
}

访问权限修饰符 interface 接口名 {
    抽象方法1;
    抽象方法2;
    抽象方法3;
}

public class XX extends YY implements ZZ {
    // XXX
}

public class InterfaceDemo {
        public static void main(String[] args) {
                Cat cat = new Cat();
                cat.clumb()
        }
}

public class Cat implements Clumbing {

        @Override
        public void clumb() {
                System.out.println("猫会爬树");
        }

}

//定义了一个爬树的接口
public interface Clumbing {
        //抽象方法
        public abstract void clumb();
}

interface 缉毒{
        public abstract void 缉毒();
}
//定义犬科的共性功能
abstract class 犬科{
    public abstract void 吃饭();
    public abstract void 吼叫();
}
// 缉毒犬属于犬科一种，让其继承犬科，获取犬科的特性，
//由于缉毒犬具有缉毒功能，那么它只要实现缉毒接口即可，这样即保证缉毒犬具备犬科的特性，也拥有了缉毒的功能
class 缉毒犬 extends 犬科 implements 缉毒{

        public void 缉毒() {
        }
        void 吃饭() {
        }
        void 吼叫() {
        }
}
class 缉毒猪 implements 缉毒{
        public void 缉毒() {
        }
}

public class TestDemo {
        public static void main(String[] args) {
                //多态
                Animal a = new Cat();
                
                a.eat();
        }
}

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

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

/*
 * 多态的好处：提高了程序的扩展性
 *                 具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作。
 * 多态的弊端：不能使用子类的特有功能
 */
public class TestDemo {
        public static void main(String[] args) {
                AnimalOperator ao = new AnimalOperator();
                Cat c = new Cat();
                ao.useAnimal(c);
                
                Dog d = new Dog();
                ao.useAnimal(d);
                
                Pig p = new Pig();
                ao.useAnimal(p);
        }
}

public class AnimalOperator {
        /*
        public void useAnimal(Cat c) { //Cat c = new Cat();
                c.eat();
        }
        
        public void useAnimal(Dog d) { //Dog d = new Dog();
                d.eat();
        }
        */
        
        public void useAnimal(Animal a) { //Animal a = new Cat();
                a.eat();
        }
}

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

public class Dog extends Animal {
        public void eat() {
                System.out.println("狗啃骨头");
        }
        
        public void lookDoor() {
                System.out.println("狗看门");
        }
}

public class Pig extends Animal {
        public void eat() {
                System.out.println("猪拱白菜");
        }
}

/*
*        向上转型
*                从子到父
*                父类引用指向子类对象
*        向下转型
*                从父到子
*                父类引用转为子类对象
*/
public class TestDemo {
        public static void main(String[] args) {
                //多态
                Animal a = new Cat(); //向上转型
                a.eat();
                
                //a.playGame();
                //多态的弊端：无法访问子类特有方法
                //现在我就想使用子类特有方法，怎么办呢?
                //创建子类对象就可以了
                /*
                Cat c = new Cat();
                c.eat();
                c.playGame();
                */
                //现在的代码虽然可以访问子类的特有功能，但是不合理
                //因为我们发现内存中有两个猫类的对象
                //这个时候，我们得想办法把多态中的猫对象还原
                //这个时候，就要使用多态中的转型了
                //父类引用转为子类对象
                Cat c = (Cat)a;
                c.eat();
                c.playGame();
        }
}

public class Cat extends Animal {
        public void eat() {
                System.out.println("猫吃鱼");
        }
        
        public void playGame() {
                System.out.println("猫捉迷藏");
        }
}

public class Animal {
        public void eat() {
                System.out.println("吃东西");
        }
}

Animal animal = new Dog();
if (animal instanceof Dog) {
    // 说明animal的确是一个Dog
}

public class TestDemo {
        public static void main(String[] args) {
                //多态
                Animal a = new Cat(); //向下转型
    Cat c = new Cat();
    if(a instanceof Cat)
    c = a
                c.eat();
                c.playGame();
        }
}

public class Cat extends Animal {
        public void eat() {
                System.out.println("猫吃鱼");
        }
        
        public void playGame() {
                System.out.println("猫捉迷藏");
        }
}

public class Animal {
        public void eat() {
                System.out.println("吃东西");
        }
}

package xyz.kbws;
import java.util.Scanner;
import java.util.Random;

java.util.Scanner
//带有包的类，创建对象格式：包名.类名 变量名 = new包名.类名();
java.util.Scanner scan = new java.util.Scanner(System.in);

//导入包前的方式
//创建对象
java.util.Random r1 = new java.util.Random();
java.util.Random r2 = new java.util.Random();
java.util.Scanner sc1 = new java.util.Scanner(System.in);
java.util.Scanner sc2 = new java.util.Scanner(System.in);

//导入包后的方式
import java.util.Random;
import java.util.Scanner;
//创建对象
Random r1 = new Random();
Random r2 = new Random();
Scanner sc1 = new Scanner(System.in);
Scanner sc2 = new Scanner(System.in);

class XX {}
final class YY extends XX{} //可以继承XX类
class ZZ extends YY{} //不能继承Fu类

class Father {
        // final修饰的方法，不可以被覆盖，但可以继承使用
    public final void method1(){}
    public void method2(){}
}
class Son extends Father {
        //重写method2方法
        public final void method2(){}
}

final int i = 20;
i = 30; //赋值报错，final修饰的变量只能赋值一次

final Person s = new Person();
Person p2 = new Person();
p = p2; //final修饰的变量p，所记录的地址值不能改变
p.name = "小明";//可以更改p对象中name属性值

class Demo {
        //直接赋值
        final int m = 100;
        
        //final修饰的成员变量，需要在创建对象前赋值，否则报错。
        final int n; 
        public Demo(){
                //可以在创建对象时所调用的构造方法中，为变量n赋值
                n = 2020;
        }
}

class 汽车 { //外部类
        class 发动机 { //内部类
        }
}

class 外部类 { 
        修饰符 class 内部类 {
                //其他代码
        }
}

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

public class InnerClass {
    //访问内部类
    public static void main(String[] args) {
        //创建内部类对象
        Body.Heart bh = new Body().new Heart();
        //调用内部类中的方法
        bh.jump();
    }
}

class Body {//外部类，身体
    private boolean life= true; //生命状态
    public class Heart { //内部类，心脏
        public void jump() {
            System.out.println("心脏在跳动");
            System.out.println("生命状态" + life); //访问外部类成员变量
        }
    }
}

class 外部类 { 
        修饰符 返回值类型 方法名(参数) {
                class 内部类 {
                        //其他代码
                }
        }
}

class Party {//外部类，聚会
        public void puffBall(){// 吹气球方法
                class Ball {// 内部类，气球
              public void puff(){
                                     System.out.println("气球膨胀了");
                          }
                }
        //创建内部类对象，调用puff方法
        new Ball().puff();

        }
}
public class InnerClass {
        //访问内部类
        public static void main(String[] args) {
                //创建外部类对象
                Party p = new Party();
                //调用外部类中的puffBall方法
                p.puffBall();
        }
}

new 父类或接口(){
        //进行方法重写
};

//已经存在的父类：
public abstract class Person{
        public abstract void eat();
}
//定义并创建该父类的子类对象，并用多态的方式赋值给父类引用变量
Person  p = new Person(){
        public void eat() {
                System.out.println(“eating.......”);
        }
};
//调用eat方法
p.eat();

new Pers
   on(){
        public void eat() {
                System.out.println(“eating.......”);
        }
}.eat();

package com.atguigu.exception;

import org.junit.Test;

public class TestStackOverflowError {
    @Test
    public void test01(){
        //StackOverflowError
        recursion();
    }

    public void recursion(){ //递归方法
        recursion(); 
    }
}

package com.atguigu.exception;

import org.junit.Test;

public class TestOutOfMemoryError {
    @Test
    public void test02(){
        //OutOfMemoryError
        //方式一：
        int[] arr = new int[Integer.MAX_VALUE];
    }
    @Test
    public void test03(){
        //OutOfMemoryError
        //方式二：
        StringBuilder s = new StringBuilder();
        while(true){
            s.append("atguigu");
        }
    }
}

package com.atguigu.exception;

import org.junit.Test;

import java.util.Scanner;

public class TestRuntimeException {
    @Test
    public void test01(){
        //NullPointerException
        int[][] arr = new int[3][];
        System.out.println(arr[0].length);
    }

    @Test
    public void test02(){
        //ClassCastException
        Object obj = 15;
        String str = (String) obj;
    }

    @Test
    public void test03(){
        //ArrayIndexOutOfBoundsException
        int[] arr = new int[5];
        for (int i = 1; i <= 5; i++) {
            System.out.println(arr[i]);
        }
    }

    @Test
    public void test04(){
        //InputMismatchException
        Scanner input = new Scanner(System.in);
        System.out.print("请输入一个整数：");//输入非整数
        int num = input.nextInt();
        input.close();
    }

    @Test
    public void test05(){
        int a = 1;
        int b = 0;
        //ArithmeticException
        System.out.println(a/b);
    }
}

package com.atguigu.exception;

import org.junit.Test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class TestCheckedException {
    @Test
    public void test06() {
        Thread.sleep(1000);//休眠1秒  InterruptedException
    }

    @Test
    public void test07(){
        Class c = Class.forName("java.lang.String");//ClassNotFoundException
    }

    @Test
    public void test08() {
        Connection conn = DriverManager.getConnection("....");  //SQLException
    }
    @Test
    public void test09()  {
        FileInputStream fis = new FileInputStream("尚硅谷Java秘籍.txt"); //FileNotFoundException
    }
    @Test
    public void test10() {
        File file = new File("尚硅谷Java秘籍.txt");
                FileInputStream fis = new FileInputStream(file);//FileNotFoundException
                int b = fis.read();//IOException
                while(b != -1){
                        System.out.print((char)b);
                        b = fis.read();//IOException
                }
                
                fis.close();//IOException
    }
}

try{
        ......        //可能产生异常的代码
}
catch( 异常类型1 e ){
        ......        //当产生异常类型1型异常时的处置措施
}
catch( 异常类型2 e ){
        ......         //当产生异常类型2型异常时的处置措施
}  
finally{
        ...... //无论是否发生异常，都无条件执行的语句
}

try{
     
}finally{
    
}

package com.atguigu.keyword;

import java.util.InputMismatchException;
import java.util.Scanner;

public class TestFinally {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        try {
            System.out.print("请输入第一个整数：");
            int a = input.nextInt();
            System.out.print("请输入第二个整数：");
            int b = input.nextInt();
            int result = a/b;
            System.out.println(a + "/" + b +"=" + result);
        } catch (InputMismatchException e) {
            System.out.println("数字格式不正确，请输入两个整数");
        }catch (ArithmeticException e){
            System.out.println("第二个整数不能为0");
        } finally {
            System.out.println("程序结束，释放资源");
            input.close();
        }
    }
    
    @Test
    public void test1(){
        FileInputStream fis = null;
        try{
            File file = new File("hello1.txt");
            fis = new FileInputStream(file);//FileNotFoundException
            int b = fis.read();//IOException
            while(b != -1){
                System.out.print((char)b);
                b = fis.read();//IOException
            }

        }catch(IOException e){
            e.printStackTrace();
        }finally{
            try {
                if(fis != null)
                    fis.close();//IOException
            } catch (IOException e) {
                e.printStackTrace();
            }        
        }
    }
}