JAVA高级-1

常用API

第一章 API

产品说明书

第二章 Scanner类（输入）

功能：获取键盘输入

package day7_12.demo01_Scanner;

import  java.util.Scanner;      //1、导包
/*
功能：获取键盘输入

引用类型一般使用步骤
    1、导包：
        import 包路径 类名称
        如果需要使用的目标类和当前类处于同一个包下，则可以省略导包语句
        只有java.lang包下的内容不需要导包，其余的都需要import语句
    2、创建
        类名称 对象名=new 类名称();
    3、使用
        对象名.成员方法名()
*/

/*
    获取键盘输入的一个int数字：int num =sc.nextInt();
    获取键盘输入的一个字符串：String str =sc.next();
*/
public class demo01_Scanner {
    public static void main(String[] args) {
        //2、创建
        Scanner sc=new Scanner(System.in);
        //system.in表示从键盘输入

        //3、获取键盘输入的int数字
        int num =sc.nextInt();
        System.out.println("输入的int数字是："+num);

        String str =sc.next();
        System.out.println("输入的字符串是："+str);
    }
}

练习题

1、获取键盘输入的两个数字求和

package day7_12.demo01_Scanner;
import java.util.Scanner;

public class Scanner_exercise01 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int one=scanner.nextInt();
        int two=scanner.nextInt();
        System.out.println(one+"+"+two+"="+(one+two));
    }
}

package day7_12.demo01_Scanner;
import java.util.Scanner;

public class Scanner_exercise01 {
    public static void main(String[] args) {
            Scanner scanner=new Scanner(System.in);
        int one=scanner.nextInt();
        int two=scanner.nextInt();
        int san=scanner.nextInt();
        int a=one>two?one:two;
        int max=a>san?a:san;
        System.out.println("最大值是："+max);
    }
}

匿名对象

只能使用一次

new person().name="张三";			//把张三交给匿名对象

第三章 Random（随机数）

功能：用来生成随机数

package cn.java_gj.demo713;

import java.util.Random;

public class demo01random {
    public static void main(String[] args) {
        Random r =new Random();
        int num=r.nextInt();
        System.out.println("随机数是："+num );
    }
}

指定生成的随机值范围（左闭右开区间）

package cn.java_gj.demo713;

import java.util.Random;

public class demo01random {
    public static void main(String[] args) {
        Random r =new Random();
        int num=r.nextInt(1000)+1;	//生成1-1000之间的随机数字
        System.out.println("随机数是："+num );
    }
}

猜数字

package cn.java_gj.demo713;

import java.util.Random;
import java.util.Scanner;

public class demo01random {
    public static void main(String[] args) {
        Random r =new Random();
        Scanner s=new Scanner(System.in);
        int num=r.nextInt(100)+1;
        int num1=0;
        do {
             num1= s.nextInt();
             if (num>num1){
                 System.out.println("猜小了");
             }else if(num<num1){
                 System.out.println("猜大了");
             }else{
                 System.out.println("OK!");
             }
        }while (num!=num1);
    }
}

第四章 Arraylist（集合）

package cn.java_gj.demo713;
import java.util.ArrayList;
/*
数组的长度不可以发生改变
但是ArrayList集合的长度是可以随意变化的


对于ArrayList来说，有一个尖括号<E>代表泛型
泛型：也就是装在集合元素当中所有元素，全都是统一的类型
注意：泛型只能是引用类型，不能是基本类型
**/

public class demo02ArrayList {
    public static void main(String[] args) {
        //创建了一个ArrayList集合，集合的名称是list，里面装的全都是string类型的数据
        ArrayList<String> list=new ArrayList<>();
        //直接打印输出不会输出地址值，而是会输出保存的内容
        //如果内容是空，输出[]；
        //如果有多个字符串，会用，进行分割
        System.out.println(list);
        list.add("张三");
        System.out.println(list);
        list.add("罗翔");
        list.add("张大仙");
        list.add("树叶");
        list.add("马保国");
        System.out.println(list);
    }
}

创建数据类型后不要放入其他数据类型，会报错

集合常用的操作语句

package cn.java_gj.demo713;
import java.util.ArrayList;
/*
数组的长度不可以发生改变
但是ArrayList集合的长度是可以随意变化的


对于ArrayList来说，有一个尖括号<E>代表泛型
泛型：也就是装在集合元素当中所有元素，全都是统一的类型
注意：泛型只能是引用类型，不能是基本类型
**/

public class demo02ArrayList {
    public static void main(String[] args) {
        //创建了一个ArrayList集合，集合的名称是list，里面装的全都是string类型的数据
        ArrayList<String> list=new ArrayList<>();
        //直接打印输出不会输出地址值，而是会输出保存的内容
        //如果内容是空，输出[]；
        //如果有多个字符串，会用，进行分割
        System.out.println(list);
     /*    list.add("张三");
       System.out.println(list);
        list.add("罗翔");
        list.add("张大仙");
        list.add("树叶");
        list.add("马保国");
        System.out.println(list);*/


        //添加.add，会返回一个布尔值来表示添加的状态
        boolean success=   list.add("张三");
        System.out.println(list);
        System.out.println("添加状态是否成功："+success);
        list.add("罗翔");
        list.add("张大仙");
        list.add("树叶");
        list.add("马保国");

        //从集合中获取元素.get。索引值从0开始
        System.out.println(list.get(3));        //读取3号索引
        System.out.println(list);

        //从集合中删除元素.remove,并返回删除的值
        String whoremove = list.remove(3);//删除索引为3的值
        System.out.println(list);
        System.out.println("被删除的是："+whoremove);


        //从集合中获取集合的长度.size（也就是元素的个数）
        int length=list.size();
        System.out.println("集合的长度是："+length);
    }
}

集合的遍历

 //集合的遍历
        for (int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }

集合放置其他类型的数据

其他手法与上面字符串一模一样

练习

package cn.java_gj.demo713;

import java.util.ArrayList;
import java.util.Random;
//        生成6个1-33之间的随机整数，添加到集合并遍历
public class arraylist_lianxi {
    public static void main(String[] args) {

        ArrayList<Integer> intlist=new ArrayList<>();
        Random r=new Random();
        for (int i = 0; i <6 ; i++) {
            intlist.add(r.nextInt(33)+1);
        }
        //遍历
        for (int i = 0; i < intlist.size(); i++) {
            System.out.println(intlist.get(i));
        }
    }
}

package cn.java_gj.demo713;

public class student {
    public String name;
    public int age;
//使用快捷键alt+insert可进行自动生成下面代码
    public student() {
    }

    public student(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;
    }
}

package cn.java_gj.demo713;

import java.util.ArrayList;
import java.util.Random;

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

        //自定义student类，创建四个学生对象，添加到集合
     /*   student a=new student("张三",18);
        student b=new student("李四",18);
        student c=new student("王五",18);
        student d=new student("赵六",18);*/
        ArrayList<student> studentlist=new ArrayList<>();
        studentlist.add( new student("张三",18));
        studentlist.add( new student("李四",18));
        studentlist.add( new student("王五",18));
        studentlist.add( new student("赵六",18));

        for (int i = 0; i < studentlist.size(); i++) {
            System.out.println(studentlist.get(i).getName()+":"+studentlist.get(i).getAge());
        }
    }
}

3 集合也能当做方法的参数的

package cn.java_gj.demo713;

import java.util.ArrayList;
import java.util.Random;

public class arraylist_lianxi {
    public static void main(String[] args) {
        //定义以指定格式打印集合的方法（ArrayList）作为参数，使用{}扩起来，使用@分割元素
        ArrayList<Integer> intlist=new ArrayList<>();
        Random r=new Random();
        for (int i = 0; i <6 ; i++) {
            intlist.add(r.nextInt(33)+1);
        }
        printArraylist(intlist);
    }
    //定义打印方法
    public static void printArraylist(ArrayList<Integer> list){
        System.out.print("{");
        //遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
            if (i==(list.size()-1)){

            }else {
                System.out.print(" @ ");

            }
        }
        System.out.print("}");
    }
}

package cn.java_gj.demo713;

import java.util.ArrayList;
import java.util.Random;

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

        //用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合中
        ArrayList<Integer> intlist=new ArrayList<>();
        ArrayList<Integer> intlistso=new ArrayList<>();
        Random r=new Random();
        for (int i = 0; i <20 ; i++) {
            intlist.add(r.nextInt(33)+1);
        }
        intlistso= printArraylist(intlist);
        System.out.println(intlistso);
    }
    public static ArrayList<Integer> printArraylist(ArrayList<Integer> list) {
        ArrayList<Integer> lists=new ArrayList<>();
        //遍历
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i) % 2 == 0) {
                lists.add(list.get(i));
            }
        }
        return lists;
    }

}

第五章 String类（字符串）

构造方法

常量池

字符串比较相关方法

package cn.gjdemo715;



public class demo01string {

    public static void main(String[] args) {
        String str1="Hello";
        String str2="Hello";
        char[] charArray={'H','e','l','l','o'};
        String str3=new String(charArray);

        //根据内容进行比较
        System.out.println(str1.equals(str2));  //true
        System.out.println(str2.equals(str3));  //true
        System.out.println(str2.equals("Hello"));  //true
        //比较格式推荐实用前面字符串后面是对象的格式，来避免空指针
        String str5=null;
        System.out.println("abc".equals(str5));     //推荐 false
//        System.out.println(str5.equals("abc"));     //不推荐 会报空指针异常的错误
        System.out.println("===========================");

        //忽略大小写比较
        String strA="Java";
        String strB="java";
        System.out.println(strA.equals(strB));  //false，严格区分大小写
        System.out.println(strA.equalsIgnoreCase(strB));    //true 忽略大小写

    }
}

字符串的获取相关方法

public int length () ：返回此字符串的长度。
public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
public char charAt (int index) ：返回指定索引处的 char值。
public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。

package cn.gjdemo715;

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

        ///计算字符串长度
        int len ="kjdashfkjdsahfkjsdahjkf".length();
        System.out.println("字符串长度是："+ len);
        System.out.println("===========");

        //字符串的拼接（字符串不能随意改变）是常量
        String str1="Hello";
        String str2="World";
        String str3=str1.concat(str2);
        String str4=str1+str2;
        System.out.println(str1);       //Hello
        System.out.println(str2);       //World
        System.out.println(str3);   //HelloWorld
        System.out.println(str4);   //HelloWorld
        System.out.println("===========");

        //获取索引位置的单个字符串
        System.out.println(str3.charAt(1)); //e（从下标0开始计数）
        System.out.println("===========");

        //获取参数字符串在本来字符串中出现的第一次索引的位置
        //如果没有，就返回-1值
        System.out.println(str3.indexOf("llo"));    //2
    }
}

字符串的截取方法

public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

 package cn.gjdemo715;

public class demo03string_cut_out {
    public static void main(String[] args) {
        String str="helloWorld";
        System.out.println(str.substring(5));      //World
        System.out.println(str.substring(4,7));      //oWo

    }
}

字符串的转换方法

public char[] toCharArray () ：将此字符串转换为新的字符数组。
public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。

package cn.gjdemo715;

import java.nio.charset.StandardCharsets;

public class demo04string_convert {
    public static void main(String[] args) {
        //将字符串拆分成单个字符数组
        char[] chats="Hello".toCharArray();
        for (int i = 0; i < chats.length; i++) {
            System.out.println(chats[i]);
            //hello
        }
        System.out.println("===========================");

        //转化成字节数组
        byte[] bytes="Hello".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        /*
        72
        101
        108
        108
        111
        */
        System.out.println("===========================");

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

字符串的分割

public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

package cn.gjdemo715;

public class demo05string_split { 
    public static void main(String[] args) {
        String str1="aaa,bbb,ccc,ddd";
        String [] array1=str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
/*
aaa
bbb
ccc
ddd
* */
    }
}

注意事项：split方法的参数其实是一个“正则表达式”，如果切割的标准是.（英文据点）需要使用转义\.来实现

练习

拼接字符串

定义一个方法，把数组{1,2,3}按照指定个格式拼接成一个字符串。格式参照如下：[word1#word2#word3]。

package cn.gjdemo715;

public class stringlianxi {
    //定义一个方法，把数组{1,2,3}按照指定个格式拼接成一个字符串。格式参照如下：[word1#word2#word3]。

    public static void main(String[] args) {
        int[] array={1,2,3};    //定义数组
        String s=forArrayToString(array);   //调用方法
        System.out.println(s);      //输出字符串
        //[1#2#3]
    }

    public static String forArrayToString(int[] array){
        String s = new String("[");
        for (int i = 0; i < array.length; i++) {
            if (i== array.length-1){
                s=s.concat(array[i]+"]");
            }else {
                s=s.concat(array[i]+"#");
            }
        }
        return s;
    }
}

统计字符个数

键盘录入一个字符，统计字符串中大小写字母及数字字符个数

 public static void main(String[] args) {
        Scanner inster=new Scanner(System.in);
        String s=inster.next();

        int bigCount=0;
        int smallCount=0;
        int numberCount=0;

        for (int i = 0; i <s.length() ; i++) {
            char ch=s.charAt(i);
            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);
    }

或者使用tochararray转化成字符串数组后在进行比较

第六章静态static关键字

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

修饰对象

package cn.gjdemo716;

public class demo01static {
    public static void main(String[] args) {
        student one=new student("张三",18);
        student.room="j1-101";
        System.out.println("姓名："+one.getName()
                +",年龄："+one.getAge()+",教室："+one.room+"，学号："+one.getId());
        student two=new student("李四",18);
        System.out.println("姓名："+two.getName()
                +",年龄："+two.getAge()+",教室："+two.room+"，学号："+two.getId());
    }
}

package cn.gjdemo716;

public class student {
    private int id;
    private String name;
    private int age;
    static  String room;
    private static int idCounter=0;  //学号计数器，每当new一个新对象，计数器++

    public student() {
        idCounter++;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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;
    }
}

会把第一个用户设置的教室带入到全局

内存图

修饰方法

package cn.gjdemo716;

public class Myclass {
    public void method(){
        System.out.println("普通成员方法");
    }

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

 package cn.gjdemo716;

/*
如果没有static关键字，那么必须要先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

无论是成员变量还是成员方法，如果有了static，都推荐实用类名称进行调用
静态变量：类名称.静态变量
静态方法：类名称.静态方法()
对于本类中的静态发放，可以省略类名称

注意事项：
1、静态不能直接访问非静态。
原因：因为在内存当中是【先】有静态内容，【后】有非静态内容
2、静态方法中不能使用this关键字
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象
*/
public class demo02staticmMethod {
    public static void main(String[] args) {
        Myclass obj=new Myclass();      //创建对象
        //使用咩有static关键字的内容
        obj.method();

        //对于静态方法来说，可以通过对象名进行调用，也可以通过类名调用
        Myclass.methodStatic();         //推荐
        obj.methodStatic();             //不推荐

    }

}

静态代码块

静态代码块
静态代码块：定义在成员位置，使用static修饰的代码块{ }。
位置：类中方法外。
执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
格式：
// 访问类变量
类名.类变量名；
// 调用静态方法
类名.静态方法名(参数)；
public class StuDemo2 {
public static void main(String[] args) {
// 访问类变量
System.out.println(Student.numberOfStudent);
// 调用静态方法
Student.showNum();
}
}

小贴士：
static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况
下，去调用方法。下面将介绍两个工具类，来体现static 方法的便利。

第七章 Arrays

public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。
public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。

如果是数值，sort默认按照升序从小到大
如果是字符串，sort默认按照字母升序
如果是自定义的列席，那么这个自定义的类需要有Comparable或者Comparator接口支持

package cn.gjdemo717;

import java.util.Arrays;

public class demo01arrays {
    public static void main(String[] args) {
        int [] intArray={66,11,88,99,55,22};
        String intStr= Arrays.toString(intArray);
        System.out.println(intStr);
        //[66, 11, 88, 99, 55, 22]

        //public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。
        Arrays.sort(intArray);
        System.out.println(Arrays.toString(intArray));
        //[11, 22, 55, 66, 88, 99]

        //练习请使用 Arrays 相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印
        /*String two=Arrays.toString(intArray);
        for (int i = two.length()-1; i >0 ; i--) {
            System.out.println(two.charAt(i));
        }*/
        String str="ndksahbfjkdsahfjksdahjklfh";
        char[] chars=str.toCharArray();         //把字符串变成字符数组
        Arrays.sort(chars);                     //排序
        //倒印
        for (int i = chars.length-1; i >0 ; i--) {
            System.out.print(chars[i]+" , ");
        }
    }

}

第八章 Math类

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

public static double abs(double a) ：返回 double 值的绝对值。
public static double ceil(double a) ：返回大于等于参数的最小的整数。（不是四舍五入，是取整）
public static double floor(double a) ：返回小于等于参数最大的整数。（不是四舍五入，是取整）
public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)
public PI：表示圆周率

package cn.gjdemo717;

public class demo02Math {
    public static void main(String[] args) {
        //取绝对值
        System.out.println(Math.abs(3.14)); //3.14
        System.out.println(Math.abs(0));    //0
        System.out.println(Math.abs(-250));     //250
        System.out.println("==========================");

        //向上取整
        System.out.println(Math.ceil(3.1));  //4.0
        System.out.println("==========================");

        //向下取整
        System.out.println(Math.floor(4.9));   //4.0
        System.out.println("==========================");

        //四舍五入
        System.out.println(Math.round(4.5));    //5
        System.out.println(Math.round(4.4));    //4

    }
}

练习

请使用 Math 相关的API，计算在 -10.8 到 5.9 之间，绝对值大于 6 或者小于 2.1 的整数有多少个？

package cn.gjdemo717;

public class Mathlx {
    public static void main(String[] args) {
        int count=0;    //用来统计个数
        double min =-10.8;
        double max=5.9;
        for (int i = (int) min; i <max ; i++) {
            if (Math.abs(i)>6||Math.abs(i)<2.1){
                System.out.print(i+" ");
                count++;
            }
        }
        System.out.println(count);
    }
}
//-10 -9 -8 -7 -2 -1 0 1 2 9

继承与多态

第一章继承

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

继承的基本格式

例子

package cn.gjdemo718;

public class demo01jc {
    public static void main(String[] args) {
        Student one=new Student();
        one.method();           //父类method执行！
        one.print();

        System.out.println("===================");
        Student2 two=new Student2();
        two.method();           //父类method执行！
        two.print2();

        System.out.println("===================");
        Employee three=new Employee();
        three.method();
    }

    //父类只能执行自己的方法
    //子类可以执行自己和父类的方法，但是不能执行其他子类的方法
    
}

package cn.gjdemo718;

public class Employee {
    public void method(){
        System.out.println("父类method执行！");
    }
}

package cn.gjdemo718;

public class Student2 extends Employee{
    public void print2(){
        System.out.println("子类student2执行");
    }
}

package cn.gjdemo718;

//子类使用extends引用父类名称
public class Student extends Employee{
    public void print(){
        System.out.println("子类student执行");
    }
}

执行效果

当参数与父类重名的时候，优先使用本类的参数。如果本类没有，才去向父类继承。

继承的子、父、局部变量的使用方式

局部变量：直接写成员变量名
本类成员变量：this.成员变量名
父类成员变量：super.成员变量名

package cn.gjdemo718.demo02;

public class my_threeMethod {
    public static void main(String[] args) {
        zi zi=new zi();
        zi.method();
    }
}

package cn.gjdemo718.demo02;

public class fu {
    int num=10;
}

package cn.gjdemo718.demo02;

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，父类成员变量
    }
}

如果是方法，也是同上，谁创建优先用谁，如果子类没有，则向上找。

继承中方法的覆盖重写

方法覆盖重写的注意事项：
1、必须保证父子类之间方法的名称相同，参数列表也相同。
@Override：写在方法前面，用来检测是不是有效的正确覆盖重写

当出现不一致时检测会报错

2、子类方法的返回值必须【小于等于】父类方法的返回值范围
前提：java.lang.object类是所有类的公共最高父类，其他的类都比他小

3、子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > （default）> private
备注：（default）不是关键字default，而是什么都不写，留空。

小于就会报错

package cn.gjdemo718.demo03;

public class Zi extends Fu{
    @java.lang.Override
    public String method(){
        return null;
    }
}

package cn.gjdemo718.demo03;

public class Fu {
    public Object method(){
        return 0;
    }
}

覆盖重写的应用

设计原则：对于已经投入使用的类，尽量不要进行修改，推荐定义一个新的类，来重复利用其中共性内容，并且添加改动新内容。

举例说明
当一个手机要新增加来电显示头像和名字时，采用覆盖重写的方法
其中使用到super关键字

package cn.extend.demo01;

//老手机
public class Phone {
    public void call(){
        System.out.println("打电话");
    }
    public void send(){
        System.out.println("发短信");
    }
    public void show(){
        System.out.println("显示号码");
    }
}

package cn.extend.demo01;

//新手机多出来电显示功能
public class NewPhone extends Phone {
    @Override
    public void show(){
        super.show(); //把父类的show方法拿过来接着使用
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}

package cn.extend.demo01;

public class RunPhone {
    public static void main(String[] args) {
        //老手机
        Phone phone=new Phone();
        phone.call();
        phone.send();
        phone.show();
        System.out.println("==================");


        NewPhone newPhone=new NewPhone();
        newPhone.call();
        newPhone.send();
        newPhone.show();
    }

    /* 显示
打电话
发短信
显示号码
==================
打电话
发短信
显示号码
显示姓名
显示头像
* */
}

继承关系中构造方法的访问特点

1、子类构造方法中有一个默认隐含的“super()”调用。所以一定先调用父类后子类
2、如果父类不是无参构造方法（父类方法需要传参），则可以使用super(参数）来实现重载调用
3、super的父类构造待用，必须是子类构造方法的第一个语句。且不能多次调用

举例

package cn.extend.demo02;

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

package cn.extend.demo02;

public class Zi extends Fu{
    public  Zi(){
//        super();    系统自带，对应父类无参构造方法
        super(1);    //当父类有参时，用super实现重载调用
        System.out.println("子类构造方法!");
    }
}

package cn.extend.demo02;

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


    }

/*输出：先父后子
父类构造方法！
子类构造方法!
* */
}

super关键自的三种用法

1：在子类的成员方法中，访问父类的成员变量
2：在子类成员中，访问父类的成员方法
3：在子类的构造方法中，访问父类的构造方法

package cn.extend.demo03;

public class Fu {
    int num=666;
    public void  method(){
        System.out.println("父类方法");
    }
}

package cn.extend.demo03;

public class Zi extends Fu{
    int num=7777;
    public void methodZi(){
    //用法1，在子类成员中，访问父类的成员变量
        System.out.println(super.num);
    }

    //用法2：在子类成员中，访问父类的成员方法
    public void  method(){
        super.method(); //访问父类方法
        System.out.println("子类方法");
    }

    //用法3：在子类的构造方法中，访问父类的构造方法
    public Zi(){
        //默认赠送super
    }
}

package cn.extend.demo03;

public class Run {
    public static void main(String[] args) {
        Zi zi =new Zi();
        zi.methodZi();
        zi.method();
    }
}

this关键字的用法

super关键字用来访问父类内容，this关键字用来访问本类内容
1、在本类成员方法中，访问本类的成员变量
2、在本类的成员方法中，访问本类的另一个成员方法。
3、在本类的构造方法中，访问本类的另一个构造方法。
a:其中this也必须是构造方法的第一个语句，也是唯一一个
b:super和this两种构造调用不能同时使用，因为他们都要求唯一（使用this后将不会默认赠送super）

package cn.extend.demo04;

public class Fu {
    int num=30;
}

package cn.extend.demo04;

public class Zi extends Fu{
/*
 super关键字用来访问父类内容，this关键字用来访问本类内容


 1、在本类成员方法中，访问本类的成员变量
 2、在本类的成员方法中，访问本类的另一个成员方法。
 3、在本类的构造方法中，访问本类的另一个构造方法。
    a:其中this也必须是构造方法的第一个语句，也是唯一一个
    b:super和this两种构造调用不能同时使用，因为他们都要求唯一（使用this后将不会默认赠送super）
* */
    int num =20;
    public void showNum(){
        int num=10;
        System.out.println(num);  //输出局部变量
        System.out.println(this.num);  //输出子类成员变量
        System.out.println(super.num);  //输出父类成员变量
    }

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

//2、在本类的成员方法中，访问本类的另一个成员方法。
    public void methodB(){
        methodA();
        //或者
        this.methodA();  //与上面功效一样，起强调作用，表示它不来自于父类
        System.out.println("BBB");
    }

//3、在本类的构造方法中，访问本类的另一个构造方法。（也叫构造方法的重载调用）
    public Zi(){
        this(123);  //本类的无参构造调用本类的有参构造
    }
    public Zi(int n){
        System.out.println(n);
    }
}

package cn.extend.demo04;

public class Run {
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.showNum();  //方法1
        System.out.println("================");
        zi.methodB();  //方法2
    }
}

第二章抽象类

介绍：
父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

定义：
**抽象方法 **：没有方法体的方法。
抽象类：包含抽象方法的类。

使用方法

如何使用抽象类和抽象方法：
1、不能直接创建new抽象类对象
2、必须用一个子类来继承抽象父类
3、子类必须用覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后不上方法体和大括号
4、创建子类对象进行使用

定义一个抽象类

package cn.abstraction.demo01;

/*
抽象方法：就是加上abstract关键字，然后去掉大括号直接分号结束
抽象类：抽象方法所在的类，必须是抽象类才行，在class之前加上abstract即可

如何使用抽象类和抽象方法：
1、不能直接创建new抽象类对象
2、必须用一个子类来继承抽象父类
3、子类必须用覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后不上方法体和大括号
4、创建子类对象进行使用


* */
public abstract class Animal {
//    这是一个抽象方法，代表吃东西，但是具体吃什么（大括号内容）不确定。
    public abstract void eat();


}

使用一个子类来调用父类（抽象类）

package cn.abstraction.demo01;

//2、必须用一个子类来继承抽象父类

public class Zanimal extends Animal{

    //3、子类必须用覆盖重写抽象父类当中所有的抽象方法。
    //覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后不上方法体和大括号
    public void eat(){
        System.out.println("这是重写后的抽象类");
    }
}

最后起一个方法进行运行

package cn.abstraction.demo01;

public class cat {
    public static void main(String[] args) {
//        4、创建子类对象进行使用
        Zanimal zanimal=new Zanimal();
        zanimal.eat();
    }
}

输出子类的内容

注意事项

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象
类。
理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有
意义。（如果有两个类，需要全部重写才能避免报错，两个类可以被多层嵌套，可以嵌套到孙子类）

综合案例

user类

用来存储user信息和输出用户余额

package cn.abstraction.demo02;

public class User {
    private String name; //名字
    private float money; //金额

    //无参构造
    public User() {

    }

    //两个传参
    public User(String name, float money) {
        this.name = name;
        this.money = money;
    }

    //getter和setter
    public String getName() {
        return name;
    }

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

    public float getMoney() {
        return money;
    }

    public void setMoney(float money) {
        this.money = money;
    }

//    展示当前用户的余额
    public void show(){
        System.out.println("我叫："+name+","+"我有："+money+"元");
    }
}

群主类

用来下发红包

package cn.abstraction.demo02;

import java.util.ArrayList;

public class owner extends User{
    public owner() {
    }

    public owner(String name, float money) {
        super(name, money);
    }
    public ArrayList<Float> send(int totalMoney ,int count){
//        使用集合来存储若干红包的金额
        ArrayList<Float> redList=new ArrayList<>();
//          看一下群主自己有多少钱
        float leftMoney=super.getMoney(); //群主当前的余额
        if (totalMoney>leftMoney){
            System.out.println("余额不足");
            return redList;  //返回空集合
        }
//        扣钱，其实就是重新设置余额
        super.setMoney(leftMoney-totalMoney);
        float avg =totalMoney/count;
        float mod=totalMoney%count;

        //把钱放到红包中
        for (int i = 0; i <count-1 ; i++) {
            redList.add(avg);
        }
//        最后一个红包
        float last=avg+mod;
        redList.add(last);
        return redList;
    }

}

群员类

用来领红包

package cn.abstraction.demo02;

import java.util.ArrayList;
import java.util.Random;

public class mass extends User{
    public mass() {
    }

    public mass(String name, float money) {
        super(name, money);
    }

    public void receive(ArrayList<Float>list){
        int index=new Random().nextInt(list.size());
//        根据索引，从集合中删除
        float delta=list.remove(index);
//        获取我当前钱包的金额
        float money=super.getMoney();
//        修改金额为抢红包后的金额
        super.setMoney(money+delta);
    }
}

主体

package cn.abstraction.demo02;

import java.util.ArrayList;

public class run {
    public static void main(String[] args) {
//        设置群主
        owner owners=new owner("群主",200);
//        设置群员
        mass one=new mass("群员A",0);
        mass two=new mass("群员B",20);
        mass three=new mass("群员C",0);

        owners.show();
        one.show();
        two.show();
        three.show();
        System.out.println("===============");

//        群主发红包
        ArrayList<Float>redList=owners.send(80,3);
//        群员领红包
        one.receive(redList);
        two.receive(redList);
        three.receive(redList);
//        打印红包余额
        owners.show();
        one.show();
        two.show();
        three.show();
    }


}

第三章接口

package cn.prot.demo01;


/*
接口就是多个类的公共规范
接口是一种引用数据类型，最重要的内容就是其中的抽象方法

如何定义一个接口格式
public interface 接口名称{
    //接口内容
}

备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java -->.class。

如果是java 7，那么接口中可以包含的内容有
1、常量
2、抽象方法

如果是java8还可以包含
1、默认方法
2、静态方法

如果是java9还可以包含
私有方法


接口使用步骤
1、接口不能直接使用，必须有个“实现类”来实现该接口
格式：
public class 实现类名称 inmplements 接口名称{
    //...
}
2、接口的实现类必须覆盖重写（实现）接口中所有的抽象方法
实现：去掉abstract关键字，加上方法体大括号

3、创建实现类的对象进行使用。
注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类

*/
public class interfaces {
    public static void main(String[] args) {
//        错误写法！不能直接new接口对象使用
//        Myinterface inter =new Myinterface();

//        创建实现类的对象使用
        MyInterfacerun impl =new MyInterfacerun();
        impl.methodAbs1();
//        输出：这是第一个方法 
    }

}

定义接口

package cn.prot.demo01;

/*
任何版本的java中，接口都能定义抽象方法
格式：
public abstract 返回值类型 方法名称（参数列表）；

注意事项：
1、接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2、上面两个关键字修饰符可以选择性省略
3、方法的三要素可以随意定义


*/

public interface Myinterface {

//    这是一个抽象方法
    public abstract void methodAbs1();
    abstract void methodAbs12();
    public void methodAbs13();
    void methodAbs14();
}

实现抽象方法

使用alt+回车快捷键补全

实现类

package cn.prot.demo01;

public class MyInterfacerun implements Myinterface{
    @Override
    public void methodAbs1() {
        System.out.println("这是第1个方法");
    }

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

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

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

接口的默认方法的使用

package cn.prot.demo02;
/*
从java8开始，接口里允许定义默认方法
public default 返回值类型 方法名称（参数列表）{
    方法体
}
备注：接口当中的默认方法，可以解决接口升级的问题

* */

public interface MyInterfaceDefaultI {
//    抽象方法
    public abstract void methodAbs();
//    当你再使用上面的方法定义一个新的抽象方法时，需要重新覆盖重写，你又不想覆盖重写，就需要用到默认方法

//    新添加的方法改成默认方法
    public default void methodAbs2(){
        System.out.println("这是新添加的默认方法");
    }
}

package cn.prot.demo02;

public class MyInterfaceDefault implements MyInterfaceDefaultI{

    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法AAA");
    }
}

package cn.prot.demo02;

public class MyInterfaceDefaultB implements MyInterfaceDefaultI{
    @Override
    public void methodAbs() {
        System.out.println("实现了抽象方法BBB");
    }

    @Override
    public void methodAbs2() {
        /*MyInterfaceDefaultI.super.methodAbs2();*/
        System.out.println("实现类B覆盖重写了接口的默认方法");
    }
}

package cn.prot.demo02;
/*
1、接口的默认方法，可以通过接口实现类对象，直接调用
2、接口的默认方法，也可以被接口实现类进行覆盖重写
 */
public class demo02run {
    public static void main(String[] args) {
        MyInterfaceDefault a=new MyInterfaceDefault();
        a.methodAbs();  //实现了抽象方法AAA
        a.methodAbs2(); //这是新添加的默认方法

        System.out.println("===============");
        MyInterfaceDefaultB B=new MyInterfaceDefaultB();
        B.methodAbs();
        B.methodAbs2();

    }
}

实现了抽象方法AAA
这是新添加的默认方法
===============
实现了抽象方法BBB
实现类B覆盖重写了接口的默认方法

接口的静态方法的使用

package cn.prot.demo03;
/*
从java8开始，接口当中允许定义静态方法
public static 返回值类型 方法名称(参数列表){
    方法体
}
提示：就是将abstract或者default换成static即可，带上方法体
* */
public interface MyinterfaceStatic {
    public static void methodStatic(){
        System.out.println("这是接口的静态方法！");
    }
}

package cn.prot.demo03;

public class MyinterfaceStaticImpl implements MyinterfaceStatic{

}

	package cn.prot.demo03;
/*
注意事项：不能通过接口实现类的对象来调用接口当中的静态方法
正确用法：通过接口名称，直接调用其中的静态方法
格式：
接口名称.静态方法名
 */
public class Demo03Interface {
    public static void main(String[] args) {
//        创建实现类对象
        MyinterfaceStaticImpl A=new MyinterfaceStaticImpl();

        //        错误写法
        //        A.methodStatic();

//        直接通过接口名称调用静态方法
        MyinterfaceStatic.methodStatic(); //这是接口的静态方法！


// 可以不用创建实现类对象直接通过接口名称调用静态方法

    }
}

接口的私有方法的使用

package cn.prot.demo04;

public interface MyInterfacePrivateA {


    public default void methodDefault1(){
        System.out.println("默认方法1");
        methodCommon();
    }
    public default void methodDefault2(){
        System.out.println("默认方法2");
        methodCommon();
    }

/*
问题描述：
需要抽取一个共有方法用来解决两个默认方法之间重复代码的问题
但是这个共有方法不应该让实现类使用。（私有化，不能单独使用）
* */
/*//    去掉重复代码，解决方案一
    public default void methodCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
    }*/

/*
解决方案：
从java9开始，接口当中允许定义私有方法
1、普通私有方法，解决多个默认方法之间重复代码问题
格式：
private 返回值类型 方法名称（参数列表）{
    方法体
}

2、静态私有方法，解决多个静态方法之间重复代码问题
private static 返回值类型 方法名称（参数列表）{
    方法体
}
* */
    private void methodCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
    }

//    静态方法
    public static void methodStatic1(){
        System.out.println("静态方法1");
        methodCommon1();
    }
    public static void methodStatic2(){
        System.out.println("静态方法2");
        methodCommon1();
    }

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

package cn.prot.demo04;

public class MyinterfacePrivateAlmpl implements MyInterfacePrivateA{
    public void methodAnother(){
        //直接访问到了接口中的默认方法，这样是不合法的应该只允许被接口中的默认方法调用，而不是被单独调用
//        methodCommon();
    }

}

package cn.prot.demo04;

public class Demo04Interface {
    public static void main(String[] args) {
//        访问接口私有的静态方法
        MyInterfacePrivateA.methodStatic1();
        MyInterfacePrivateA.methodStatic2();
    }
}

接口的常量定义和使用

package cn.prot.demo05;

/*
接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。
从效果来看，这相当接口的【常量】
格式：
public static final 数据类型 常量名称=数据值
注意：
一旦使用final关键字进行修饰，说明不可改变。

注意事项：
接口中的常量，可以省略public static final，但是默认添加
接口中的常量，必须赋值
* */
public interface MyInterfaceConst {
    //这其实就是一个常量，一旦赋值，不可修改（不可变的量大写命名,用下划线分割单词）
    public static final int NUM=10;

}

package cn.prot.demo05;
//使用接口常量
public class Demo05Interface {
    public static void main(String[] args) {
        System.out.println(MyInterfaceConst.NUM);
        //输出10
    }
}

总结

在java9+版本中接口的内容可以有

1、成员变量其实是常量，格式：

[public] [static] [final] 数据类型 常量名称 =数据值；

注意：
常量必须进行赋值，而且一旦赋值不能改变
常量名称完全大写，多个单词用下划线进行分隔。

2、接口中最重要的就是抽象方法，格式：

[public] [abstract] 返回值类型 方法名称(参数列表);

注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类

3、从java8开始，接口里允许定义默认方法，格式：

用来解决接口新增问题，默认接口可以不用重写直接使用，当然也可以被覆盖重写

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

注意：默认方法也可以被覆盖重写

4、从java8开始，接口里允许定义静态方法，格式：

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

注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

5、从java9开始，接口里允许定义私有方法，格式：

普通私有方法：private 返回值类型 方法名称(参数列表){方法体}
静态私有方法：private static 返回值类型 方法名称(参数列表){方法体}

注意：private的方法只有自己才能调用，不能被实现类或别人使用

继承父类并实现多个接口

package cn.prot.demo06;

public interface Demo06InterfaceA {

    //错误写法！接口不能有静态代码块
    /*    static {

    }*/
    //错误写法！接口不能有构造方法
  /*  public MyInterface(){

    }*/


    public abstract void methodA();
    public abstract void methodAbs();

    public default void methodDefault(){
        System.out.println("默认方法AAA");
    }


}

package cn.prot.demo06;

public interface Demo06InterfaceB {

   public abstract void methodB();
   public abstract void methodAbs();

   public default void methodDefault(){
      System.out.println("默认方法BBB");
   }
}

package cn.prot.demo06;


//使用接口的时候，需要注意
/*
 * 1、接口是没有静态代码块或者构造方法的。
 * 2、一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
 *
 * 格式：
 * public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{
 *   //覆盖重写所有的抽象方法
 * }
 *
 * */
public class MyInterfaceImpl implements Demo06InterfaceA,Demo06InterfaceB{
    @Override
    public void methodA() {
        System.out.println("覆盖重写了A");
    }



    @Override
    public void methodB() {
        System.out.println("覆盖重写了B");
    }

    /*
     * 3、如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
     * */
    @Override
    public void methodAbs() {
        System.out.println("覆盖重写了AB接口都有的抽象方法");
    }

    @Override
    public void methodDefault() {
        System.out.println("对多个接口当中冲突的默认方法进行覆盖重写");
    }
}

package cn.prot.demo06;
/*
 * 4、如果实现类没有覆盖重写所有接口当中所有抽象方法，那么实现类就必须是一个抽象类。
 * */
public abstract class  MyInterfaceAbstract implements Demo06InterfaceB,Demo06InterfaceA{
    @Override
    public void methodA() {

    }

    @Override
    public void methodAbs() {

    }

/*
* 5、如果实现类所实现的多个接口当中存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
* */
    @Override
    public void methodDefault() {
        System.out.println("对多个接口当中冲突的默认方法进行覆盖重写");
    }


}

父优先于接口

package cn.prot.demo06;

public interface MyInterface {
    public  default void method(){
        System.out.println("接口的默认方法");
    }
}

package cn.prot.demo06;

public class Fu {
    public void method(){
        System.out.println("父类方法");
    }
}

package cn.prot.demo06;

public class Zi extends Fu implements MyInterface{
    /*
     * 在java中继承是要优先于接口的
     * 6、一个类如果直接父类当中的方法和接口当中的默认方法产生了冲突，优先采用父类的方法
     *
     * */

}

接口之间的多继承

package cn.prot.demo07;

/*
* 1、类与类之间是单继承的，直接父类只能有一个
* 2、类与接口之间是多实现的，一个类可以实现多个接口。
* 3、接口与接口之间是多继承的。
*
* 注意事项
* 1、多个父接口中的抽象方法如果重复，没有关系（因为他们没有方法体）
* 2、多个父接口中的默认方法如果重复，就有关系，子接口必须进行默认方法覆盖重写，而且必须带有default关键字
* */
public class Demo07Relations {


}

package cn.prot.demo07;

public interface MyInterfaceA {
    public abstract void methodA();
    public abstract void methodCommon();

    public default void methodDefault(){
        System.out.println("AAA");
    }
}

package cn.prot.demo07;

public interface MyInterfaceB {
    public abstract void methodB();
    public abstract void methodCommon();

    public default void methodDefault(){
        System.out.println("AAA");
    }
}

1、多个父接口中的抽象方法如果重复，没有关系（因为他们没有方法体）

package cn.prot.demo07;
/*
* 可以看见覆盖重写了4个方法，其中methodCommon方法为AB共有，所以这里只算一个
* */
public class MyInterfaceImp implements MyInterface {
    @Override
    public void method() {

    }

    @Override
    public void methodA() {

    }

    @Override
    public void methodB() {

    }

    @Override
    public void methodCommon() {

    }
}

2、多个父接口中的默认方法如果重复，就有关系，子接口必须进行默认方法覆盖重写，而且必须带有default关键字

package cn.prot.demo07;

public interface MyInterface extends MyInterfaceA,MyInterfaceB{
    public abstract void method();


    @Override
    default void methodDefault() {
        MyInterfaceA.super.methodDefault();
    }
}

第三章多态

多态使用方法

父子继承：

相当于子类会被当成父类运行

package cn.polymorphic.demo01;

public class FU {
    public void method(){
        System.out.println("父类方法");
    }
}

package cn.polymorphic.demo01;

public class Zi extends FU {
    @Override
    public void method() {
        System.out.println("子类方法");
    }
}

使用接口实现

package cn.polymorphic.demo01;

public interface test {
    public abstract void test();
}

package cn.polymorphic.demo01;

public class runTest implements test{
    @Override
    public void test() {
        System.out.println("用接口实现多态");
    }
}

package cn.polymorphic.demo01;
/*
* 代码当中体现多态性其实就是一句话：父类引用指向子类对象。
* 格式：
* 父类名称 对象名=new 子类名称();
* 或者：
* 接口名称 对象名=new 实现类名称();
* */
public class Demo01Multi {
    public static void main(String[] args) {
//        使用多态的写法
//        左侧父类的引用，指向了右侧子类的对象
        FU obj=new Zi();

        obj.method();  //会运行子类方法

//        使用接口实现多态
        test t=new runTest();
        t.test();       //用接口实现多态

    }
}

多态中成员变量的使用特点

package cn.polymorphic.demo02;

public class Fu {
    int num=10;

    public void showNum(){
        System.out.println(num);
    }
}

package cn.polymorphic.demo02;

public class Zi extends Fu{
    int num=20;

    @Override
    public void showNum() {
        System.out.println(num);  //子类覆盖重写
    }
}

package cn.polymorphic.demo02;

import cn.polymorphic.demo01.runTest;
import cn.polymorphic.demo01.test;

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




        Fu obj=new Zi();
//        直接通过对象名称访问成员变量，值取等号左边，没有再向上访问
        System.out.println(obj.num);  //输出10（父类的量）

//        间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有就向上找
        obj.showNum();  //输出20，虽然属于父类，但是在子类中覆盖重写了，就变成20了
    }
}

多态中成员方法的使用特点

package cn.polymorphic.demo03;

public class Fu {
    public void method(){
        System.out.println("父类方法");
    }
    public void methodFu(){
        System.out.println("父类特有方法");
    }
}

package cn.polymorphic.demo03;

public class Zi extends Fu{
    public void method(){
        System.out.println("子类方法");
    }
    public void methodZi(){
        System.out.println("子类特有方法");
    }
}

package cn.polymorphic.demo03;

/*
* 在多态代码中，成员方法的访问规则是：
*   看new的是谁，就优先用谁，没有就向上找
口诀：编译看左边，运行看右边。
*
成员变量：编译看左边，运行还看左边
成员方法：编译看左边，运行看右边。





*/


public class Demo03MultiMethod {
    public static void main(String[] args) {
        Fu obj=new Zi();
        obj.method();   //输出子类方法，因为子类有，所以直接输出子类
        obj.methodFu(); //输出父类特有方法，因为子类没有所以向上查找找到父类

        //错误写法，编译的时候优先看左边，左边父类没有methodZi这个方法
//        obj.methodZi();


    }

}

多态的好处

无论右边的定义换成什么，左边的调用方法都不变

多态对象向上转型

一般向上转型不会出现问题

父类定义抽象类

package cn.polymorphic.demo04;

public class Animal {
    public void eat(){

    }
}

子类覆盖重写

package cn.polymorphic.demo04;

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

最后输出，编译看左边，父类存在该方法，

package cn.polymorphic.demo04;

public class demo04Main {
    public static void main(String[] args) {
//        对象的向上转型就是：父类引用指向之类对象
        Animal animal=new cat();
        animal.eat();
    }
}

多态对象的向下转移

//        向下转型，进行“还原”动作
        cat Cat=(cat) animal;   //将动物还原成猫
        Cat.catchMouse();  //调用猫自己的特有子类

多态使用关键字instanceof来判断父类引用本来

package cn.polymorphic.demo04;

/*

如何才能知道一个父类引用的对象本来是什么子类?

格式：
对象 instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当作后面类型的实列


* */
public class Demo04Instanceof {
    public static void main(String[] args) {
        Animal animal =new cat();
        animal.eat();

        //如果希望调用子类特有方法，需要向下转型
        //判断父类引用是不是cat
        if(animal instanceof cat){
            cat Cat=(cat) animal;
            Cat.catchMouse();
        }

    }
}

综合案例

package cn.polymorphic.demo05;

public interface USB {
    public abstract void open();    //打开设备
    public abstract void close();   //关闭设备

}

package cn.polymorphic.demo05;

public class Mouse implements USB{

    @Override
    public void open() {
        System.out.println("打开鼠标");
    }

    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }

    public void click(){
        System.out.println("鼠标点击");
    }
}

package cn.polymorphic.demo05;

public class Keyboard implements USB{

    @Override
    public void open() {
        System.out.println("打开键盘");
    }

    @Override
    public void close() {
        System.out.println("关闭键盘");
    }

    public void types(){
        System.out.println("键盘输入");
    }
}

package cn.polymorphic.demo05;

public class Computer {
    public void powerOn(){
        System.out.println("电脑开机");
    }
    public void powerOff(){
        System.out.println("电脑关机");
    }

//使用usb设备的方法，使用接口作为方法的参数
    public void useDevice(USB usb){
        usb.open();

        if (usb instanceof Mouse){
            Mouse mouse=(Mouse) usb; //向下转型
            mouse.click();
        }else if (usb instanceof Keyboard){
            Keyboard keyboard=(Keyboard) usb;
            keyboard.types();
        }

        usb.close();
    }
}

package cn.polymorphic.demo05;

public class DemoMain {
    public static void main(String[] args) {
//        创建一个笔记本电脑
        Computer computer=new Computer();
        computer.powerOn();
//准备一个鼠标
//        Mouse mouse=new Mouse();
//        向上转型
        USB usbMouse=new Mouse();  //多态写法，左父右子
        computer.useDevice(usbMouse);


//        创建一个键盘
        Keyboard keyboard=new Keyboard();
        computer.useDevice(keyboard);

        computer.powerOff();
    }
}

第四章 final关键字

简介

package cn.Finals.demo01;

/*
final关键字代表最终，不可改变的
1、可以用来修饰一个类
2、可以用来修饰一个方法
3、可以用来修饰一个局部变量
4、可以用来修饰一个成员变量



*/
public class demo01 {

}

1、可以用来修饰一个类

package cn.Finals.demo01;

/*
当final关键字用来修饰一个类的时候，格式：
public final class 类名称{
  //...
}
含义：当前这个类不能有任何子类（太监类），但是允许有父类
* */

public final class MyClass {

}

2、可以用来修饰一个方法

package cn.Finals.demo01;

/*
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能覆盖重写。
格式：
修饰符 final 返回值类型 方法名称（参数列表）{
    //方法体
}

注意事项：
对于类、方法来说，abstract 关键字和final关键字不能同时使用，因为矛盾
* */
public class Fu {
    public final void method(){
        System.out.println("父类方法执行");
    }
}

package cn.Finals.demo01;

public class Zi extends Fu{
    @Override
    public void method() {  //当fu添加final关键字后，zi 这边如果尝试覆盖就会报错
        System.out.println("子类覆盖重写");
    }
}

3、可以用来修饰一个局部变量

package cn.Finals.demo01;


/*
final一旦用来修饰局部变量，将使得该变量不可改变

* */
public class finalInt {
    public void method(){
        int num=10;
        final  int num1=20;
//        num1=30; //会报错，因为不可改变

    }

    public static void main(String[] args) {
//        对于基本类型来说，不可变的是变量当中的数据不可改变
//        对于引用类型来说，不可变说的是变量当中的地址值不可改变

        student student=new student("张三");
        System.out.println(student);
        System.out.println(student.getName());

        student=new student("李四");  //第二次new重新赋值会改变地址值
        System.out.println(student);
        System.out.println(student.getName());

        final student student1=new student("王五");
//        student1=new student("老毕登");    //会报错，不能更改地址值
        System.out.println(student1);
        student1.setName("老壁灯");        //但是你可以用方法进行值的更变，虽然更变值，但是地址没变，允许
        System.out.println(student1.getName());
    }
}

4、可以用来修饰一个成员变量

package cn.Finals.demo01;

/*
对于成员变量来说，如果使用final这个关键字修饰，那么这个变量也照样不可变
1、由于成员变量具有默认值，所以使用final之后必须手动赋值，不会再给默认值了
2、对于final成员变量，要么使用直接复制，要么通过构造方法赋值
3、必须保证类当中所有重载的构造方法，最终都会对final的成员变量进行赋值。
* */
public class Person {
    //这里加final会报错，因为这里默认会取默认值定为不可改变，不符合逻辑
    private /*final*/ String name;


//    private final String name1="zhang";  //方法2，直接赋值

    public Person() {
        name="zhang";   //方法二，构造方法赋值
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

第五章权限修饰符

java中有四种权限修饰符
  public 》protected （保护的，专门给子类用的）》（default）不写 》private
同一个类
同一个包
不同包子类
不同包非子类

	public	protected	（default）	private
同一个类	yes	yes	yes	yes
同一个包	yes	yes	yes	NO
不同包子类	yes	yes	NO	NO
不同包非子类	yes	NO	NO	NO

同一个类

//演示同一个类能访问


public class MyClass {

    //    int num =10;
    public void method(){
        System.out.println(num);
    }
}

同一个包

//    演示同一个包
    //    public int num=1; //ok
//     int num=1; //ok
     protected int num=1; //ok
//    private      int num=1; //NO

第二个类

package cn.demo02.authority.demo01;

public class MyClass01 {


    public void anotherMethod(){
        System.out.println(new MyClass().num);
    }
}

不同包子类

    //不同包子类
//    public int num =10;     //ok
//    protected int num =10;     //ok
//    int num =10;     //NO
    private int num =10;     //NO

package cn.demo02.authority.demo01.ZI;

import cn.demo02.authority.demo01.MyClass01;

public class Zi extends MyClass01 {
    public void method(){
        System.out.println(super.num);
    }
}

不同包非子类

    //不同包非子类
    public int num =10;     //ok
//    protected int num =10;     //NO
//    int num =10;     //NO
//    private int num =10;     //NO

package cn.demo02.authority.demo01.ZI;

import cn.demo02.authority.demo01.MyClass01;

public class zI1 {
    public void method(){
        System.out.println(new MyClass01().num);
    }
}

第六章内部类

成员内部类定义

package cn.demo02.interior.demo01;
/*
如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类
 内部类单独列出不能正常使用

 分类：
 1、成员内部类
 2、局部内部类（包含匿名内部类）

成员内部类定义格式
修饰符 class 外部类名称{
    修饰符 class 内部类名称{
        //。。
    }
    //..
}

注意：内用外，随意访问；外用内，需要内部类对象

* */
public class Demo01InnerClass {
}

成员内部类的使用

package cn.demo02.interior.demo01;
/*
如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类
 内部类单独列出不能正常使用

 分类：
 1、成员内部类
 2、局部内部类（包含匿名内部类）

成员内部类定义格式
修饰符 class 外部类名称{
    修饰符 class 内部类名称{
        //。。
    }
    //..
}

注意：内用外，随意访问；外用内，需要内部类对象


=======================================
如何使用成员内部类？有两种方式：
1、间接方式：在外部类的方法当中，使用内部类：然后main知识调用外部类的方法
2、直接方式：
        公式： 类名称 对象名 =new 类名称();
        外部类名称.内部类名称 对象名=new 外部类名称().new 内部类名称();
* */
public class Demo01InnerClass {
    public static void main(String[] args) {
        Body body=new Body(); //外部类对象
        //1、通过外部类对象调用外部方法间接调用内部类
        body.methodBody();

        System.out.println("==================================");
        //2、直接方式
        Body.Heart heart=new Body().new Heart();
        heart.beat();
    }
}

package cn.demo02.interior.demo01;

public class Body {   //外部类

    public class Heart{  //成员内部类
//        内部类的方法
        public void beat(){
            System.out.println("运转");
            System.out.println("我叫"+name);
        }


    }
//    外部成员变量
    private String name;

//    外部类方法
    public void methodBody(){
        System.out.println("外部类的方法");
        new Heart().beat();  //匿名对象
    }

    public Body() {
    }

    public Body(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

内部类的同名变量访问

package cn.demo02.interior.demo01;

public class Outer {
    int num=10;   //外部类成员变量
    public class Inner{
        int num=20;   //内部类的成员变量


        public void methodInner(){
            int num=30;  //内部类方法的局部变量
            System.out.println(num); //局部变量，就近原则
            System.out.println(this.num); //内部类的成员变量
            System.out.println(Outer.this.num); //外部类的成员变量

        }
    }
}

package cn.demo02.interior.demo01;

public class Demo01innerClass02 {
    public static void main(String[] args) {
        Outer.Inner obj=new Outer().new Inner();
        obj.methodInner();
    }
}

局部内部类定义

package cn.demo02.interior.demo02;

/*
如果一个类是定义在一个方法内部的，那么这就是一个局部内部类
“局部”：只有当期那所属的方法才能使用它，出了这个方法外面就不能用了

定义格式：
修饰符 class 外部类名称{
    修饰符 返回值名称 外部类方法名称(参数列表){
        class 局部内部类名称{
            // ...
        }
    }
}
*/
public class Outer {

    public void methodOuter(){
        class Inner{    //局部内部类
            int num =10;
            public void methodInner(){
                System.out.println(num);
            }
        }
//        只能自己使用，如果需要调用，需要在方法内部进行调用
        Inner inner=new Inner();
        inner.methodInner();
    }
}

package cn.demo02.interior.demo02;

public class demoMain {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.methodOuter();
    }
}

局部内部类的final问题

package cn.demo02.interior.demo02;

//局部内部类如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】也就是不能改变的

/*
原因：
1.new出来的对象在堆内存当中
2.局部变量是跟踪方法走的，在栈内存当中，方法运行完毕后，立刻出栈，局部变量会消失
3.但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。
* */
//也就是说堆没了，但是对象会收录堆中传递的局部变量，进行记载，直到垃圾回收

public class MyOuter {
    public void methodOuter(){
        int num=10; //所在方法的局部变量

        class MyInner{
            public void methodInner(){
                System.out.println(num);
            }
        }
    }
}

匿名内部类

定义接口

package cn.demo02.interior.demo03;

public interface MyInterface {
    public void method();
}

覆盖重写

package cn.demo02.interior.demo03;

public class MyInterfaceImpl implements MyInterface{
    @Override
    public void method() {
        System.out.println("传统方法覆盖重写接口");
    }
}

匿名内部类定义

package cn.demo02.interior.demo03;

/*
如果接口的实现类（或者父类的子类）只需要使用唯一一次，那么这种情况下可以省略该类的定义
也就是说可以省略创建重写文件，而改为使用【匿名内部类】

匿名内部类的定义格式：
接口名称 对象名 =new 接口名称(){
   //覆盖重写所有抽象方法

};

* */




public class DemoMain {
    public static void main(String[] args) {
//        传统方法覆盖重写接口
        MyInterfaceImpl objs=new MyInterfaceImpl();
        objs.method();



//        定义匿名内部类
        MyInterface obj=new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法！");
            }
        };
        obj.method();
    }
}

运行结果

类作为成员变量类型

成员变量不仅仅可以使用基本类型，还能使用类

package cn.demo02.interior.demo04;

public class Hero {

    private String name; //名字
    private int age;     //年龄
    private Weapon weapon;  //英雄武器

    public Hero() {
    }

    public Hero(String name, int age, Weapon weapon) {
        this.name = name;
        this.age = age;
        this.weapon = weapon;
    }

    public void attack(){
        System.out.println("名字："+name+",年龄："+age+",武器："+weapon.getCode());
    }
    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 Weapon getWeapon() {
        return weapon;
    }

    public void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }
}

package cn.demo02.interior.demo04;

public class Weapon {
    private String code;  //武器代号

    public Weapon() {
    }

    public Weapon(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

package cn.demo02.interior.demo04;

public class demoMain {
    public static void main(String[] args) {
        //创建一个英雄
        Hero hero=new Hero();
        hero.setName("赵云");
        hero.setAge(18);

        //创建一个武器对象
        Weapon weapon=new Weapon("破军");

        //配备武器
        hero.setWeapon(weapon);

        hero.attack();


    }
}

接口作为成员变量类型

定义名称、类型

package cn.demo02.interior.demo05;

public class Hero {
    private String name;
    private Skill skill;

    public Hero() {
    }

    public Hero(String name, Skill skill) {
        this.name = name;
        this.skill = skill;
    }

    public void attack(){
        System.out.println("名字:"+name);
        skill.use();
        System.out.println("技能释放完成！");
    }

    public String getName() {
        return name;
    }

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

    public Skill getSkill() {
        return skill;
    }

    public void setSkill(Skill skill) {
        this.skill = skill;
    }
}

创建一个接口，创建一个类

package cn.demo02.interior.demo05;

public interface Skill {
    void use();
}

覆盖重写

package cn.demo02.interior.demo05;

public class Skillmpl implements Skill{
    @Override
    public void use() {
        System.out.println("实现技能释放！");
    }
}

运行

package cn.demo02.interior.demo05;

public class DemoGame {
    public static void main(String[] args) {
        Hero hero=new Hero();
        hero.setName("赵云");

        //设置技能
//        方法一（老方法）
//        hero.setSkill(new Skillmpl());


//        方法二（使用匿名类）
/*        Skill skill=new Skill() {
            @Override
            public void use() {
                System.out.println("实现匿名类的技能释放！");
            }
        };
        hero.setSkill(skill);*/

//        方法三
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("实现匿名类的技能释放2！");
            }
        });
        hero.attack();

    }
}

运行结果

package cn.demo02.interior.demo05;

import java.util.ArrayList;
import java.util.List;

public class DemoInterface {
    public static void main(String[] args) {
        List<String> list =new ArrayList<>();

        List<String> result= addNames(list);
        for (int i = 0; i <result.size() ; i++) {
            System.out.println(result.get(i));
        }
    }

    public static List<String> addNames(List<String>list){
        list.add("test1");
        list.add("test2");
        list.add("test3");
        list.add("test4");
        return list;
    }
}

常用API第二部分

第一章 Object类

toString方法

概述：
public String toString()：返回该对象的字符串表示。
toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。
如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：

package cn.demo03.ObjectS.demo01;

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

    public Objects() {
    }

    public Objects(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;
    }

/*
    @Override
    public String toString(){
        return "1Person{"+"name='"+name+'\''+",age="+age+'}';
    }
*/



}

package cn.demo03.ObjectS.demo01;

public class Omian {
    public static void main(String[] args) {
        Objects objects=new Objects();
        objects.setAge(18);
        objects.setName("张三");
        System.out.println(objects);
       
    }
}

重写前

重写后

能看到可读性有所提升

equals方法

默认比较对象的地址值

基本使用

package cn.demo03.ObjectS.demo01;

public class equalsMain {
    public static void main(String[] args) {
        Objects P1=new Objects("张三",18);
        Objects P2=new Objects("李四",18);
        System.out.println("p1:"+P1);  //p1:cn.demo03.ObjectS.demo01.Objects@2cb4c3ab
        System.out.println("p2:"+P2);   //p2:cn.demo03.ObjectS.demo01.Objects@13c78c0b

        boolean set =P1.equals(P2);
        System.out.println(set);        //false
    }
}

使用覆盖重写把他们变成比较内容

    @Override
    public boolean equals(Object o) {
       //使用向下转型，把obj转换成Person类型
        Objects p =(Objects)o;
        //比较两个对象的属性，一个对象是this（p1），一个对象是p（obj-》p2）
        return this.name.equals(p.name) && this.age==p.age;
    }

使用效果：
当内容name和age都一样的时候，即使内存地址不一样，也会返回true

防止空指针异常

package cn.demo03.ObjectS.demo01;

public class equalsMain {
    public static void main(String[] args) {
        Objects P1=new Objects("张三",18);
        Objects P2=new Objects("张三",18);
        System.out.println("p1:"+P1);  //p1:cn.demo03.ObjectS.demo01.Objects@2cb4c3ab
        System.out.println("p2:"+P2);   //p2:cn.demo03.ObjectS.demo01.Objects@13c78c0b

        boolean set =P1.equals(P2);
        System.out.println(set);        //false

        boolean set1= java.util.Objects.equals(P1,P2);      //防止空指针异常
        System.out.println(set1);
    }
}

当P1或者P2赋值为空的时候，使用objects.equals(P1,P2)方法来避免空指针异常报错

第二章日期时间类

Date类

package cn.demo03.DATAS.demo01;

import java.util.Date;
//表示日期和时间的类，精确到毫秒，也就是千分之一秒


public class time {
    public static void main(String[] args) {
        demo04();

    }

    public static void demo01(){
        System.out.println(System.currentTimeMillis());
//        获取当前系统时间到1970年1月1日 00:00:00 经历了多少毫秒

//        把毫秒转化为日期
//        1天=24*60*60=86400秒,中国属于东八区，需要增加8个小时
    }

    public static void demo02(){
        Date date=new Date();
        System.out.println(date);       //Sun Oct 29 14:39:15 CST 2023 星期日 10月 cst中国的标准时间

    }
    //构造方法，date传参，输出毫秒对应的时间，这里输出0毫秒也就是初始时间
    public static void demo03(){
        Date date=new Date(0L);
        System.out.println(date);   //Thu Jan 01 08:00:00 CST 1970
    }

    //把日期转化成毫秒
    public static void demo04(){
        Date date=new Date();
        long time=date.getTime();
        System.out.println(time);
        //1698562118876
    }
}

DateFormat方法

使用alt+回车来让编译器忽略错误，交给虚拟机处理

package cn.demo03.DATAS.demo01;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DataForm {
    public static void main(String[] args) throws ParseException {
        dome01();
        dome02();
    }
    //把字符串还原成date日期
    public static void dome02() throws ParseException {
        SimpleDateFormat time1=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 中国");
        Date date=time1.parse("2023年10月29日 15时53分27秒 中国");
        System.out.println(date);

    }

    //使用dateformat类中的方法把日期转化为文本
    public static void dome01(){
        //设置指定模式
        SimpleDateFormat time1=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 中国");
        //把date数据转化成指定的格式输出
        Date date=new Date();
        String d=time1.format(date);
        System.out.println(date);
        System.out.println(d);
    }
}

第三章日历类

Calendar类：

package cn.demo03.Calend.demo01;

import java.util.Calendar;

public class Calender01 {
    public static void main(String[] args) {
        Calendar calendar=Calendar.getInstance();
        System.out.println(calendar);
    }
}

产出

java.util.GregorianCalendar[time=1698567177129,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2023,MONTH=9,WEEK_OF_YEAR=44,WEEK_OF_MONTH=5,DAY_OF_MONTH=29,DAY_OF_YEAR=302,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=5,AM_PM=1,HOUR=4,HOUR_OF_DAY=16,MINUTE=12,SECOND=57,MILLISECOND=129,ZONE_OFFSET=28800000,DST_OFFSET=0]

进程已结束,退出代码0

通过日历读取和设置年月日

package cn.demo03.Calend.demo01;

import java.util.Calendar;
import java.util.Date;

public class Calender01 {
    public static void main(String[] args) {
        domo02();

    }




    //日历：通过.get(指定参数)，获取指定的参数值
    private static void domo02() {

        Calendar calendar=Calendar.getInstance();
        //设置年，月，日
        calendar.set(calendar.YEAR,2044);
        calendar.set(calendar.MONTH,10);
        calendar.set(calendar.DATE,30);


        //获取年月日
        int year=calendar.get(calendar.YEAR);
        System.out.println(year);
        int mouth=calendar.get(calendar.MONTH);
        System.out.println(mouth);
        int date =calendar.get(calendar.DAY_OF_MONTH);
        System.out.println(date);


    }

    //输出全部日历内容
    public static void domo01(){
        Calendar calendar=Calendar.getInstance();
        System.out.println(calendar);
    }
}

package cn.demo03.Calend.demo01;

import java.util.Calendar;
import java.util.Date;

public class Calender01 {
    public static void main(String[] args) {
//        domo03();
//        domo04();
        domo05();
    }
    //把日历对象转换成日期对象
    private static void domo05() {
        Calendar calendar=domo01();
        Date date=calendar.getTime();
        System.out.println(date);
    }

    //对日历进行增加与减少操作
    private static void domo04() {
        Calendar calendar=domo01();
        //增加2年
        calendar.add(Calendar.YEAR,2);
        //减少两月
        calendar.add(Calendar.MONTH,-2);

        domo03(calendar);
    }

    //输出时间日期
    private static void domo03(Calendar calendar) {

        //获取年月日
        int year=calendar.get(calendar.YEAR);
        System.out.println(year);
        int mouth=calendar.get(calendar.MONTH);
        System.out.println(mouth);
        int date =calendar.get(calendar.DAY_OF_MONTH);
        System.out.println(date);

    }


    //日历：通过.get(指定参数)，获取指定的参数值
    private static void domo02(Calendar calendar) {
        //设置年，月，日
        calendar.set(calendar.YEAR,2044);//单独设置
        calendar.set(calendar.MONTH,10);
        calendar.set(calendar.DATE,30);
        calendar.set(2048,11,11);//通过重载方法进行批量设置
    }

    //输出全部日历内容
    public static Calendar  domo01(){
        Calendar calendar=Calendar.getInstance();
//        System.out.println(calendar);
        return calendar;
    }
}

第四章 system类

currentTimeMillis来打印程序的执行时间

package cn.demo03.systems.dome01;

public class systemctl01 {
    public static void main(String[] args) {
        dome01();
    }

     //使用currentTimeMillis来打印程序的执行时间
    public static void dome01(){
        long s=System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            System.out.println(i);
        }
        System.out.println("程序共耗时"+":"+(System.currentTimeMillis()-s)+"毫秒" );
    }
}

arraycopy方法，将数组中的数据拷贝到另一个数组中去

 private static void dome02() {
        int [] src={1,2,3,4,5};
        int [] los={6,7,8,9,10};
        System.out.println("拷贝前"+ Arrays.toString(los));
        System.arraycopy(src,0,los,0,3);
        //复制src的数组从下标0开始到数组los下标0开始3个元素
        System.out.println("拷贝后"+ Arrays.toString(los));

    }

第五章 StringBuilder类

也叫字符串缓冲区

字符拼接问题

package cn.demo03.StringBuilders.demo01;

public class demo1 {
    public static void main(String[] args) {
        dome01();
    }

    public static void dome01(){
    //空参数的构造方法
        StringBuilder stringBuilder=new StringBuilder();
        System.out.println("to1:"+stringBuilder.length());
    //带参数的构造方法
        StringBuilder stringBuilder1=new StringBuilder("abcdefg");
        System.out.println("to2:"+stringBuilder1);

    //使用append添加字符（链式编程）
        stringBuilder.append("adsahdujsdaf").append("true").append("你好");
        System.out.println("to3:"+stringBuilder);
    }
}