Java基础

老板来杯柠檬水

已于 2023-08-23 09:19:42 修改

阅读量533

点赞数

文章标签： java

于 2021-07-10 22:40:25 首次发布

本文链接：https://blog.csdn.net/coolesti/article/details/118641337

版权

Java基础

标识

标识符

标识符是标识类名、变量名、接口名、方法名、包名的字符串
标识符规则
由字母、$、_、数字组成，数字不能开头
大小写敏感
不能使用关键字、空格、+、-和.等特殊符号
true、false、null不是关键字，但也不能用作标识符

数据类型

基本数据类型

数值型
整型：byte（1个字节），short（2个字节），int（4个字节），long（8个字节）
浮点类型：float（4个字节），double（8个字节）
字符型：char（2个字节）
布尔类型：boolean（1位）1个字节8位

引用数据类型

类：class
接口：interface
数组：array

不同类型直接进行运算规则
1.小范围数据类型自动转换成大范围数据类型（自动转换）
2.大范围类型可以强转成小范围数据类型（强制转换），可能会丢失数据
3.boolean数据不能跟其他数据类型相互转换
4.String类型跟基本类型运算最终都是转成字符串类型

运算符

分隔符

,、;、{}

算数运算符

+、-、*、/、%、++、- -
++，- -，用在变量的前后。
前置先运算后加减，后置先加减后运算

关系运算符

<、>、>=、<=、==、!=

逻辑运算符

!、&、|、^、~、&&、||、<<、>>
逻辑运算符& && | ||区别
相同点：连接两个表达式，返回结果boolean类型
不同点：&、|连接的表达式都会被执行；&&、||连接的表达式中前面的表达式能够决定整个表达式的结果，则后面的表达式不再执行

位运算按位 &与 |或 ^异或 ~非

设 a=10(00001010)，b=20(00010100)
a&b = 0 a|b = 30 a^b =30
00001010 00001010 00001010
00010100 00010100 00010100
00000000 00011110 00011110

左移右移运算符

<<(左移)
5<<2的意思为5的二进制位往左挪两位，右边补0，5的二进制位是0000 0101 ，就是把有效值101往左挪两位就是0001 0100 ，正数左边第一位补0，负数补1，等于乘于2的n次方，十进制位是20
>>(右移)
凡位运算符都是把值先转换成二进制再进行后续的处理，5的二进制位是0000 0101，右移两位就是把101左移后为0000 0001，正数左边第一位补0，负数补1，等于除于2的n次方，结果为1

赋值运算符

=
扩展赋值运算符
+=、-=、*=、/=、%=、^=、&=、|=

流程控制语句

if语句

switch语句

循环语句

for循环

while循环

do-while循环

while、do while区别
前者先判断在执行，后置先执行一次循环体语句后再判断

结束循环语句

break

continue

循环结束的方式
1、循环条件不满足
2、使用break语句

1、break，结束循环
2、continue，结束本次循环，开始下一次循环

数组

数组的声明

数据类型[ ] 数组名 = new 数据类型[大小];
例子
short[] sh = new short[5];
String[] str = new String[]{“12”,“34”,“56”}; 直接赋值
boolean[] boo = {false,true,false};

数组的特点即其他

1、同一数据类型
2、有序存放，连续不间断，每个元素都编号，第一个元素从0开始，使用数组名[编号]访问元素
3、数组长度固定，不能动态删除或增加元素个数，只能修改元素内容
4、数组是引用数据类型，通过数组名引用连续的内存空间
5、数组的元素可以重复

6、给数组的各个元素赋值，系统默认会给刚刚元素初始化值，不同的元素类型初始化值也不一样
4种整形（byte、short、int、long）初始值0
2种小数（float、double）初始值0.0
char 初始值为空

数组排序

Arrays.sort(数组名)

对数组元素按照从小到大顺序排序

选择排序

用数组的第一个元素逐个跟之后的每个元素进行比较，交换位置。

for(int j=i+1;j<a.length;j++){//具体每一轮排序规则，数组中第一个元素跟后面的每个元素逐个比较
            if(a[i]>a[j]){//a[i]指当前排序轮中的第一个元素，a[j]指后面的各元素；
            int temp;//交换两个数的值
            temp = a[i];
            a[i]=a[j];
            a[j]=temp;
                }
            }

冒泡排序

比较相邻的元素，将小的放到前面，比较一轮后，最大的就放到了最后面，经过n-1轮的比较完成排序。

for(int i=0;i<a.length-1;i++){//外部循环表示要经过n-1轮；
            for(int j=0;j<a.length-1-i;j++){//每一轮排序都是从第一个元素开始，两辆相邻的元素进行比较，-i指的是已经排序的元素不在重复比较；
                if(a[j]>a[j+1]){//a[i]指当前排序轮中的第一个元素，a[j]指后面的各元素；
                    int temp;//交换两个数的值
                    temp = a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }

插入排序

把数组分成两部分，假设第一个元素已经排好序，当做第一部分，依次用第二部分的第一个元素跟第一部分的每个元素进行比较。

for(int i= 1;i<a.length;i++){//把数组分成两部分，假设第一个元素排好序，当做成第一个部分，其余元素当做成第二部分
            int temp = a[i];//获取第二部分的第一个元素，用来跟第一部分的每一个元素比较
            int j;
            for(j=i-1;j>=0&&temp<a[j];j--){//用来跟第一部分的每一个元素比较，采用倒序，从右往左
                a[j+1] = a[j];//a[j]元素往后挪一个；
            }
            a[j+1] = temp;//在j的位置插入temp值；
        }

方法

方法的定义

方法定义：一段重复调用的代码块，由三部分构成
1、返回值类型，有返回值的方法（return 返回值的数据类型）、无返回值的方法（void）
2、方法名，后面小括号不能省略
3、方法体，一对大括号不能省略，大括号里面可以没有语句块（空方法）

方法调用

方式一：同一个类中，直接用方法名调用
方法二：不同类中，使用对象名，方法名调用

带参的方法

类和对象

属性—对象具有的各种特征
方法—对象执行的操作
对象：用来描述客观事物的一个实体，由一组属性和方法构成
类：具有相同属性和方法的一组对象集合

构造方法和重载

this.调用当前对象的属性或者方法，默认可以省略不写
this()调用当前类的其他构造方法
构造方法重载：在一个类中有多个构造方法，方法名一样，参数列表不同，作用是可以实现复用，使用this()复用
使用this()调用类中的其他构造方法，必须放在构造方法的第一行，不能写在其他普通方法中
普通方法重载：在一个类中有多个相同方法名的方法，参数列表不一样（参数个数，参数类型不同，参数顺序不同），和返回值没有关系，作用是可以实现方法之间的复用，使用方法名调用
方法签名： = 方法名+参数列表，一个类中不允许存在两个相同的方法签名的方法
任何一个类系统会默认提供一个无参的构造方法，但是如果定义了有参的构造方法，则系统不再提供无参的构造方法，为了程序的健壮性，建议显示写出无参的构造方法

JavaBean规范和static

JavaBean

1、必须有包
2、Java类，具有无参数构造器
3、有getXxx()和setXxx()声明的Bean属性

static

static静态关键词修饰：属性、方法、内部类、代码块

类加载顺序：
1、加载类
2、静态属性
3、静态方法、静态代码块
4、对象属性
5、对象代码块、构造方法、对象方法

静态属性：属于类属性，类加载期间初始化值，是所有对象共享的，通过类名调用
非静态属性：属于对象属性，在创建对象时会复制一份进行初始化值，不同的对象属性值可以不一样

静态方法：属于类方法，类加载期间执行的代码块，使用类名调用
非静态方法：属于对象方法，通过对象名调用

静态代码块：类加载期间执行的代码块，只会执行一次，类只会被jvm加载一次
和静态方法的区别：静态方法把静态代码块用一个方法名封装起来，方便以后再次调用

对象代码块，每创建一个对象都会执行一次，在构造方法之前执行

类的继承（extends）

类的访问权限

在这里插入图片描述

Super关键字

super. 调用父类对象的属性和方法
super() 用在构造方法第一行，系统默认提供，调用父类构造方法，要求父类必须具备无参构造方法，否则报错

this
this. 调用当前类对象的属性和方法
this() 用在构造方法第一行，调用当前类其他构造方法

方法重写

子类拥有和父类相同的方法，方法重写或者方法覆盖
重写父类方法，要求
1、方法名相等，
2、参数列表相同，
3、返回值相同或者子类，
4、访问修饰符不能低于父类的

方法重载和方法重写区别

方法重载：overload
1、方法名相同
2、参数列表不同（类型，个数，顺序）
3、和返回值无关
4、同一个类中
方法重写：override
1、方法名相等
2、参数列表相同（类型，个数，顺序）
3、返回值相同或者子类
4、访问修饰符不能低于父类的
5、用于子类继承父类关系中

在这里插入图片描述

final

final修饰词：指最终的，不能被修改的
1、修饰类，类不能被继承
2、修饰方法，方法不能被重写
3、修饰属性，属性值不能被修改

接口和抽象类

抽象类

抽象类用abstract修饰，拥有对象属性和对象方法和构造方法，不能实例化，只能被继承，通过非抽象子类实例化对象
其中抽象类的构造方法是用来被子类调用的
抽象方法abstract修饰，没有方法体，需要子类重写

抽象方法
public abstract void speak();

接口

接口全部是抽象方法，不能实例化，只能被类实现，没有构造方法，可以多继承
接口可以继承接口，使用extend，可以实现多继承，逗号隔开


    /**
     * 接口中的属性都是public static final（公共静态常量），可以省略
     */
    public static final String name = "动物名称";

    /**
     * 接口中的方法默认都是 public abstract
     */
//  public abstract void eat();
    public void eat();

类实现接口，重写接口里面的所有方法

多态性

多态：同一个引用类型，使用不同实例而执行不同操作
父类引用，子类对象
instanceof 的对比结果为 boolean 类型，判断左边引用类型是否是右边引用类型的子类或实现类

Object类

toSing()方法

1.把对象转换成字符串形式输出，由类全限定名@8为16进制的hashcode数（对象唯一标识）
2.一般建议重写toString方法，返回自定义的字符串格式

equals()方法

比较对象分为两种：“引用相等”和“对象相等”
== 比较引用值是否相等
equals是比较对象属性是否相等
Object类默认实现是比较引用值，建议子类重写

hashCode()方法

hashCode()方法要同equals方法一同覆盖

String字符串

        String s1 = new String("Hello World");//实例对象
        String s2 = "Hello World";//字面量，实例对象
        String s3 = "Hello World";

        System.out.println(s1 == s2);//false
        System.out.println(s1.equals(s2));//true,String类重写过equals方法，逐个比较字符

        System.out.println(s2 == s3);//true,字面量值相等时，引用值相等

String的方法

 public static void main(String[] args) {

        String s = " Hello World ";
        System.out.println(s);
        //去掉字符串前后空白字符
        s = s.trim();
        System.out.println(s);

        //统计字符串长度
        System.out.println(s.length());

        //字符串是否为空字符串
        System.out.println(s.isEmpty());

        //转换成大写字母
        System.out.println(s.toUpperCase());
        //转换成小写字母
        System.out.println(s.toLowerCase());

        //转换成字符数组
        char[] chars = s.toCharArray();
        //直接输出字符数组和输出字符串效果一样，其他类型的数组输出格式不一样
        System.out.println(chars);
        System.out.println(Arrays.toString(chars));
        int[] a = {1,2,3};
        System.out.println(a);
        System.out.println(Arrays.toString(a));
        //转换成字节数组
        byte[] bytes = s.getBytes();
        System.out.println(bytes);
        System.out.println(Arrays.toString(bytes));

        //获取指定位置的字符
        char c =s.charAt(0);
        System.out.println(c);

        //末尾拼接字符串
        System.out.println(s.concat("你好，世界"));

        //查找字符串中是否包含指定的字符串,包含返回true否则false
        System.out.println(s.contains("Hello"));

        //查找字符串中是否包括指定的字符或字符串，如果包含返回第一次出现的位置，如果不包含返回-1
        System.out.println("字符串中o第一次出现的位置"+s.indexOf('o'));
        //查找字符串中是否包括指定的字符或字符串，如果包含返回最后一次出现的位置，如果不包含返回-1
        System.out.println("字符串中o最后一次出现的位置"+s.lastIndexOf('o'));

        //截取字符串,指定范围截取，包括前不包括后的位置
        System.out.println(s.substring(0, 5));
        //截取字符串，从指定位置到结尾
        System.out.println(s.substring(6));

        //分割字符串成字符串数组
        String[] strings = s.split(" ");
        System.out.println(strings);//直接输出String类型的数组变量格式
        System.out.println(Arrays.toString(strings));

        //判断字符串是否以指定的字符串开始
        System.out.println(s.startsWith("Hello"));
        //判断字符串是否以指定的字符串结尾
        System.out.println(s.endsWith("World"));

        //比较两个字符串大小,如果大返回正整数，小返回负整数，相等返回0
        //比较规则，把两个字符串中逐个字符一一比较，安装ASCII顺序比较
        System.out.println(s.compareTo("Hello"));

        //判断两个字符串是否相等,相等true，不相等false
        System.out.println(a.equals("Hello"));

        //判断两个字符串是否相等,不区分大小写,相等true，不相等false
        System.out.println(s.equalsIgnoreCase("hello world"));

        //替换字符或者字符串
        System.out.println(s.replace('o', '欧'));
        System.out.println(s.replaceAll("Hello", "你好"));
    }

当多个字符串进行相互连接时用StringBuffer或者StringBuilder
字符串处理类

StringBuffer jdk1.0，速度慢，线程安全，其余都一样
StringBuilder jdk1.5，速度快，线程不安全，其余都一样

.append() 尾部追加数据
.insert() 插入数据
指定位置插入数据，从0开始
.delete() 删除数据
删除指定区间字符，序号包前不包后
.reverse() 反转字符串

正则表达式

在这里插入图片描述

在这里插入图片描述
String对正则表达式的支持
.matches() 匹配正则表达式
.split() 切割字符串位字符数组
.replaceAll 替换

例子
        String str = "010-1234567";
        String regex = "^\\d{3,4}-\\d{7}$";
        boolean flag = str.matches(regex);//匹配正则表达式
        if (flag){
            System.out.println("正确");
        }else {
            System.out.println("错误");
        }
        
        String str = "what is name?my name is lisi.";
        String regex = "[\\s\\.\\?]";
        String[] strings = str.split(regex);//正则分割
        System.out.println(Arrays.toString(strings));
        
        String s = str.replaceAll(regex,"#");//正则替换
        System.out.println(s);

包装类和内部类

包装类

内部类

内部类最大作用：封装

/**
 * 总结
 * Integer->int    .intValue()
 * int->Integer    new Integer() 构造方法
 * int->String     Integer.toString()
 * String->int     Integer.parseInt() 最常用
 * String->Integer new Integer() 构造方法
 */
public static void main(String[] args) {

        //integer1对象种包装一个基本数据类型10
        Integer integer1 = new Integer(10);
        //先把字符串20转换成整数20然后包装到对象integer2中
        Integer integer2 = new Integer("20");//数值类型的字符串,否则报错
        //把基本整数类数据30直接赋值给对象integer3，相当于把基本数据包装到对象中，自动装箱
        Integer integer3 = -128;
        Integer integer5 = -128;//Integer包装类默认是缓存一个字节大小范围的取值，只要在这个范围的值共用的是同一个实例对象，超过则创建新的实例对象
        System.out.println(integer1);
        System.out.println(integer2);
        Integer integer4 = integer1+integer2+integer3;//自动拆箱，取出基本类型数据进行运算，最后结果再自动装箱到对象中
        System.out.println(integer1 + integer2 + integer3);//对象直接进行运算，自动拆箱，会从对象中取出基本类型数据进行运算

        System.out.println(integer1 == integer2);
        System.out.println(integer1.equals(integer2));
        System.out.println(integer1 == integer3);
        System.out.println(integer1.equals(integer3));
        System.out.println(integer3 == integer5);

        int i = integer1.intValue();//把对象类型转换成基本类型
        System.out.println(i);

        int a = Integer.parseInt("10");//把数值类型的字符串转换成数值类型
        System.out.println(a);

        //十进制整形数据转换成十进制的字符串
        String s10 = Integer.toString(100);
        //十进制整形数据转换成二进制的字符串
        String s2 = Integer.toBinaryString(100);
        //十进制整形数据转换成八进制的字符串
        String s8 = Integer.toOctalString(100);
        //十进制整形数据转换成十六进制的字符串
        String s16 = Integer.toHexString(100);

        System.out.println(s2);
        System.out.println(s8);
        System.out.println(s16);

        String s = "1.23";
        double b = Double.parseDouble(s);
        System.out.println(s + 100);
        System.out.println(b + 100);

    }

成员内部类

内部类
public class OutClass {

    private String name;

    public void show(){
        System.out.println("姓名"+name);
    }

    public void test(){
        InnerClass ic = new InnerClass();//外部类通过创建内部类地对象，访问内部类的属性和方法
        ic.sex = "女";
        ic.print();
    }

    /**
     * 成员内部类，可看做成员方法,可以使用外部类地属性和方法
     * 更好的封装 多继承
     */
    public class InnerClass extends B implements A {

        private String sex;

        public void print(){
            System.out.println("姓名"+name+"性别"+sex);//可以直接访问外部类地属性
            show();//可以直接调用外部类地方法
        }
    }
    public interface A{

    }
    public abstract class B{

    }

}

测试类
public class OutClassTest {
    public static void main(String[] args) {

        //创建外部类对象
        OutClass oc = new OutClass();
        //外部类对象.new 内部类
        OutClass.InnerClass ic = oc.new InnerClass();
        ic.print();
    }
}

静态内部类

内部类
public class StaticOutClass {

    private static String name;

    public static void show(){
        System.out.println("姓名"+name);
    }

    public void test(){
        InnerClass ic = new InnerClass();//外部类通过创建内部类对象访问内部类属性和方法
        ic.print();
    }

    public static class InnerClass{

        private String sex;

        public void print(){
            System.out.println("姓名"+name+"性别"+sex);//静态内部类只能访问外部类的静态属性和静态方法
            show();
        }
    }
}

测试类
public class StaticOutclassTest {
    public static void main(String[] args) {
        //new 外部类，内部类()创建内部类对象
        StaticOutClass.InnerClass ic = new StaticOutClass.InnerClass();
        ic.print();
    }
}

局部内部类

内部类
public class LocalOutClass {

    private String name;

    public void show(){
        System.out.println("姓名"+name);
    }
    public void abc(){
        test();//外部类直接调用方法
    }

    public void test(){

        int age = 20;//局部变量

        /**
         * 局部内部类，写在方法里，看做是局部变量使用，class前只能是默认访问修饰符
         */
        class InnerClass{

            private String sex;

            public void print(){
                System.out.println("姓名"+name+"性别"+sex+"年龄"+age);//可以访问外部类的属性和方法,也可以访问本方法中的的局部变量
                show();
            }
        }
        InnerClass ic = new InnerClass();//在方法中创建内部类的对象，必须写在类的后面
        ic.print();
    }
}
测试类
public class LocalOutClassTest {
    public static void main(String[] args) {

        LocalOutClass lo = new LocalOutClass();

        lo.test();
    }
}

匿名内部类

内部类
public class AnonymousTest {

    public static void main(String[] args) {
        /**
         * 匿名内部类，用在继承关系中，不创建子类，但是也可使用父类的方法，一般只对父类方法使用一次时，如果多次使用，建议创建子类
         */
        Animal dog = new Animal() {
            @Override
            public void eat() {
                System.out.println("狗吃骨头");
            }
        };
        Animal cat = new Animal() {
            @Override
            public void eat() {
                System.out.println("猫吃鱼");
            }
        };

        dog.eat();
        cat.eat();

        /*
        Pet chicken = new Pet() {
            @Override
            public void soung() {
                System.out.println("咯咯咯");
            }
        };

        Pet duck = new Pet() {
            @Override
            public void soung() {
                System.out.println("嘎嘎嘎");
            }
        };
        chicken.soung();
        duck.soung();
        */

        //lambda表达式写法,jdk1.8新增，小括号指传递的参数1，如果只有一个参数，小括号可以省略，无参或者多个参数不能省略，多个参数直接用逗号隔开
        Pet chicken = (content) ->{
            System.out.println("鸡叫：");
        };
        Pet duck = content -> System.out.println("鸭叫：");
        chicken.soung("咯咯咯");
        duck.soung("嘎嘎嘎");
    }
}

异常和时间

异常

Java的异常处理的5个关键字
try、catch、finally、throw、throws
在这里插入图片描述

时间

Date类

Date → long getTime()
long → Date setTime()、new Date()

public static void main(String[] args) {

        //获取当前系统日期时间
        Date date = new Date();
        System.out.println(date);//默认输出时间格式； Tue Jul 20 11:29:32 CST 2021
        System.out.println(date.getTime());//当前系统时间距离距离1970-01-01 00:00:00 000 所经过的毫秒数是：1626752031997

        Date date2 = new Date(1000000000000l);
        System.out.println(date2);//Sun Sep 09 09:46:40 CST 2001

        Date date3 = new Date();
        date3.setTime(1000000000000l);
        System.out.println(date3);//Sun Sep 09 09:46:40 CST 2001
    }

SimpleDateFormat类

Date → String .format()方法
String → Date .parse() 方法

public static void main(String[] args) {

        Date now = new Date();
        System.out.println(now);//Tue Jul 20 11:55:59 CST 2021
        //2021-07-20 11:57:20
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E D");
        System.out.println(sdf.format(now));//把Date类型转换成String类型

        //计算距离2022年7月1号还剩多少天
        String str = "2022-07-01";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date date = sdf2.parse(str);//把String类型转换转换成Date类型
            long cha = date.getTime() - now.getTime();//当前距离2022年7月1号的毫秒数
            System.out.println(cha/(24*60*60*1000));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println(System.currentTimeMillis());//获取系统当前时间距离1970毫秒数
    }

Calendar类

类型转换
Calendar → long .getTimeInMillis()
long → Calendar .setTimeInMillis()
Calendar → Date .getTime()
Date→ Calendar .setTime()
获取年月日时分秒的信息的方法
.get(Calendar.各方法名)
指定日期
.set(年，月，日)
时间推移计算
.add(Calendar.各方法名，时间)
时间可用负数，表示往后推
计算最大天数
计算一个月的最大天数
.getActualMaximum(Calendar.DAY_OF_MONTH));
计算一年的最大天数
.getActualMaximum(Calendar.DAY_OF_YEAR))

 public static void main(String[] args) {

        //获取当前系统时间
        Calendar c = Calendar.getInstance();
        System.out.println(c);
        //获取系统时间毫秒数，Calender类型转换成long类型
        System.out.println(c.getTimeInMillis());
        //把long类型转换成Calendar类型
        c.setTimeInMillis(1626766769854l);
        //把Calender类型转换成Date类型
        Date now = c.getTime();
        //把Date类型转换成Calender类型
        c.setTime(now);

        //获取年份
        System.out.println(c.get(Calendar.YEAR));
        System.out.println(c.get(Calendar.MONTH));//一月份为0
        System.out.println(c.get(Calendar.DAY_OF_MONTH));
        System.out.println(c.get(Calendar.HOUR_OF_DAY));
        System.out.println(c.get(Calendar.MINUTE));
        System.out.println(c.get(Calendar.SECOND));
        System.out.println(c.get(Calendar.DAY_OF_WEEK));//星期天为1

        //指定一个日期
        c.set(2022,6,1);//2022-07-01
        System.out.println(c.getTimeInMillis());
        System.out.println(c.get(Calendar.DAY_OF_WEEK));//6 星期五

        //时间推移计算
        //前一个月
        c.add(Calendar.MONTH,-1);//2022-07-01 前一个月是 2022-06-01
        System.out.println(c.get(Calendar.DAY_OF_WEEK));
        c.add(Calendar.DAY_OF_MONTH,100);//2022-06-01之后100天
        System.out.println(c.get(Calendar.DAY_OF_WEEK));
        System.out.println(c.get(Calendar.MONTH));

        c.setTime(new Date());
        //计算一个月的最大天数
        System.out.println(c.getActualMaximum(Calendar.DAY_OF_MONTH));
        //计算一年的最大天数
        System.out.println(c.getActualMaximum(Calendar.DAY_OF_YEAR));
    }

其他时间类

LocalDate

 public static void main(String[] args) {

        //创建系统当前本地日期
        LocalDate localDate = LocalDate.now();
        System.out.println(localDate);
        //格式化日期成字符串
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
        System.out.println(localDate.format(dateTimeFormatter));//2021年07月21日
        System.out.println(localDate.plusDays(10));//在原有日期加十天
        System.out.println(localDate.minusWeeks(2));//在原有日期上减两周
        System.out.println(localDate.isLeapYear());//判断是否是闰年
        localDate = localDate.withYear(2022)
                .withMonth(7)
                .withDayOfMonth(1);

        System.out.println(localDate);
    }`

LocalTime

//获取当前系统时间
        LocalTime localTime = LocalTime.now();
        System.out.println(localTime);//09:13:47.924
        //格式化时间成字符串
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("HH:mm:ss");
        System.out.println(localTime.format(dateTimeFormatter1));//09:15:31
        //指定时间点：12:00:00
        localTime = localTime.withHour(12)
                .withMinute(0)
                .withSecond(0);
        System.out.println(localTime);//12:00:00.105

LocalDateTime

//获取当前系统日期时间
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);//2021-07-21T09:21:32.721
        //格式化日期时间成字符串
        DateTimeFormatter dateTimeFormatter2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
        System.out.println(localDateTime.format(dateTimeFormatter2));//2021年07月21日 09:29:30
        //转换成LocalDate类型
        LocalDate date = localDateTime.toLocalDate();
        //转换成LocalTime类型
        LocalTime time = localDateTime.toLocalTime();

Instant

//获取当前时区系统日期时间
        Instant instant = Instant.now();
        System.out.println(instant);//2021-07-21T01:34:37.956Z
        //获取当前系统时间距离1970-01-01 00:00:00多经历的秒数
        System.out.println(instant.getEpochSecond());//1626831403
        //获取当前系统时间距离1970-01-01 00:00:00多经历的毫秒数
        System.out.println(instant.toEpochMilli());//1626831474998

在这里插入图片描述

集合

Collection接口
List接口:不唯一，有序对象
Set接口:唯一，无序对象

List接口

不唯一，有序对象
ArrayList:遍历元素和随机访问元素的效率比较高
Linked List：插入、删除元素时效率比较高

方法总结
（新增）元素：
add、addFirst/push/offerFirst、addLast/offer/offerLast
（获取）元素不删除：列表为空报错
get、getFirst/element、getLast
获取元素并（删除）：列表为空报错
remove、removeFirst/pop、removeLast
（获取）元素不删除，列表为空返回null
peek、peekFirst、peekLast
获取元素并（删除），列表为空返回null
poll、pollFirst、poolLast

其他方法
.set 替换指定位置元素信息
.isEmpty 判断是否为空
.indexOf 元素在集合列表中首次出现的位置
.lastIndexOf 元素在集合列表中最后一次出现的位置
.clear 清空列表中的元素
.size 集合列表的元素个数

使用集合工具类Collections对集合的元素进行排序，要求集合中的元素必须要实现Comparable接口
Collections.sort();
可自定义排序规则，Integer类默认实现了Comparable接口，是按照从小到大排序，我们没办法更改具体实现类，但可以使用Comparator比较接口排序

  示例
    Collections.sort(list, new Comparator() {
        @Override
        public int compare(Object o1, Object o2) {
            Integer i1 = (Integer) o1;
            Integer i2 = (Integer) o2;
            return i2-i1;
        }
    });

  List集合遍历方式
        System.out.println("list集合遍历方式一：for+get");
        //list集合遍历方式一：for+get
        for (int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        System.out.println("list集合遍历方式二：foreach");
        //list集合遍历方式二：foreach
        for (Object o:list
             ) {
            System.out.println(o);
        }
        System.out.println("list集合遍历方式三：Iterator迭代器");
        //list集合遍历方式三：Iterator迭代器
        Iterator it = list.iterator();//获取迭代器对象
        while (it.hasNext()){//循环判断集合中是否有下一个元素，有的化返回true否则返回false
            System.out.println(it.next());//获取下一个元素
        }

Set接口

唯一，无序对象，不允许有重复对象
HashSet：无序（散列）的形式保存
TreeSet：有序的形式保存，此有序非存入顺序，无论放入顺序如何，集合都会排序后存放，放入的元素要实现接口Comparable
.add方法添加元素，无须存放，添加元素的顺序和取出元素的顺序不保证一致，重复元素（equals相同）无法添加
TreeSet .add方法只能存放同一种数据类型元素，元素必须实现Comparable接口，集合会自动根据接口的排序规则给各个元素排序
.remove 提取并删除元素
无序所以无get，set方法
foreach循环输出，它是for循环的一种高级用法，主要用于数组或者集合元素的遍历，用:隔开，前面是元素的类型，后面是用来遍历的数组名或集合名称

Set集合遍历方式        
        //set集合遍历方式一：foreach
        for (Object o:set
             ) {
            System.out.println(o);
        }
        //set集合遍历方式二：Iterator迭代器
        Iterator it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());

Map接口

键值对

Map接口常用方法

.put() 添加键值对元素，无序

.remove() 根据键删除元素

.replace() 根据键替换对于元素值
也可用 .put() 方法修改对应的值，map中不允许相同的键存在，输入相同的键则替换值

.get() 根据键获取对应的值
.keySet() 获取map中所有的键
.valuse() 获取map中所有的值
.entrySet() 获取map中所以的键值对

.containsKey() 判断是否包含指定的键
.containsValue() 判断是否包含指定的值

.size() 获取元素个数

.clear() 清空所以元素

HashMap遍历

键值遍历
        Set entrySet = map.entrySet();
        System.out.println(entrySet);

        for (Object o:entrySet
             ) {
            Map.Entry entry = (Map.Entry)o;
            System.out.println(entry.getKey()+"--"+entry.getValue());
        }

在这里插入图片描述
集合类对比

HashMap支持null键和null值，线程不安全，速度快，实现Map接口
Hashtable不支持null键和null值，线程安全，速度慢，继承Dictionary

泛型集合

指定一种数据类型的集合，不能存放其他类型的数据

数组与集合的转换

集合转数组

//数组转换成集合,只具备读功能，不具备写功能
       List<String> list = Arrays.asList(array);
       System.out.println(list);
//        list.add("赵六");//UnsupportedOperationException
//        list.remove(1);//UnsupportedOperationException
       System.out.println(list.get(1));
       
       //复制为全功能List
       list = new ArrayList<>(list);
       list.add("赵六");
       list.add("赵六");
       list.add("赵六");
       System.out.println(list);
       list.remove(1);
       System.out.println(list);

       //或放入Set集合，最大作用，去重
       HashSet<String> set = new HashSet<>(list);
       System.out.println(set);

数组转集合

      ArrayList<String> list = new ArrayList<>();
       list.add("张三");
       list.add("李四");
       list.add("王五");
       list.add("赵六");
       list.add("程琦");
       
       //集合转Object[]
       Object[] objects = list.toArray();
       System.out.println(objects);
       System.out.println(Arrays.toString(objects));
       
       //集合转指定类型数组
       String[] strings = list.toArray(new String[]{});
       for (String s:strings
            ) {
           System.out.println(s);
       }

lambda表达式流遍历

.stream()
.forEach() 输出
.filter() 过滤输出
.limit(n) 输出前n个元素
.sorted() 排序
.collect(Collectors.toList()) 把stream中数据收集存入一个新的集合对象
.collect(Collectors.groupingBy()) 根据一个或多个属性对集合中的项目进行分组
.distinct() 去除重复元素，根据两个对象equals相同
skip(n) 跳过前面n条记录

//根据年龄从小到大排序，年龄相同，在根据身高来排，.reversed() 反排序
.sorted(Comparator.comparing(Student::getAge).thenComparing(Student::getHeight).reversed())

Java输入输出（IO）

File类的常用方法

判断是否可执行
.canExecute()
判断是否可读取
.canRead()
判断是否可修改
.canWrite()
创建一个新的文件，如果文件不存在则创建返回true，否则不创建返回false
.createNewFile()
判断文件是否存在，存在返回true，否则返回false
.exists()
重命名文件，把源文件移动到了目标路径并改名
.renameTo(new File())
获取文件大小，单位是字节
.length()
获取文件名称
.getName()
获取文件路径
.println()
.getPath()
获取文件绝对路径
.getAbsolutePath()
.getAbsoluteFile()
获取文件父路径
.getParent()
获取文件的父文件对象
.getParentFile()
文件最大的使用空间，所在盘符分配的空间
.getTotalSpace()
文件可以最大空间，所在盘符可用的空间
.getUsableSpace()
文件剩余可用的空间，所在盘符可用的空间
.getFreeSpace()
文件的最后修改时间，返回毫秒数
.lastModified()
删除文件
.delete()
创建文件夹，如果存在创建失败返回false，否则返回true
.mkdir()
创建多级目录
.mkdirs()
删除文件夹，文件夹必须为空，否则删除失败
.delete()
判断文件是否是文件，是的话返回true，否则返回false
.isFile()
判断文件是否是文件夹，是的话返回true，否则返回false
.isDirectory()
获取文件夹中所有文件名称
.list()
获取文件夹中所有文件对象
.listFiles()

流的类型

根据流动方向分为：输入流，输出流
根据传输格式的不同分为：
字节流（8位、1字节），以字节位基本单位
字符流（16位、2字节），以字符为基本单位

InputStream抽象类

FileInputStream类 文件输入流，继承InputStream类，属于字节流
.read() 方法

OutputStream抽象类

FileOutputStream类 文件输出流，继承OutputStream类，属于字节流
.write() 方法

字符流

FileReader

文件读取流
gai该类将从文件中逐个的读取字符，效率比较低下，因此一般将该类对象包装到缓冲流中进行操作

//读取数据
.read()
.readLine()

BufferedReader

为字符流提供缓冲

FileWriter

文件写入流
与FileReader类相似，FileWriter类同样需要使用缓冲流进行包装

BufferedWriter

为FileWriter提供缓冲，提高效率

//向文件中写入如数据
.write()
//输出一个换行符
.newLine()
//刷新缓冲区，写入文件
.flush()

过渡流

字节流转换成字符流
InputStreamReader,OutputStreamWriter字节流与字符流直接的桥梁

//创建一个过渡流对象，把字节流转换成字符流
                InputStreamReader isr = new InputStreamReader(System.in);
                BufferedReader br = new BufferedReader(isr);

对象处理流

对象输出流，把基本类型数据或者对象类型数据输出到文件中保存，主要是用作保存程序运行的中间状态
ObjectOutputStream流、ObjectInputStream、对象序列化和反序列化、Serializable接口、Transient关键字、serialVersionUID
程序使用ObjectOutputStream流生成序列化对象文件，序列化对象文件通过ObjectInputStream反序列化生成程序，其中，处理的对象类必须实现Serializable接口，transient关键字用来修饰无需序列化的属性，并且对象类需要声明一个序列化串，对象序列化和反序列化都公用同一个序列化串

public static void main(String[] args) {

       try (
               FileOutputStream fos = new FileOutputStream("E:\\java\\temp\\a.txt");
               ObjectOutputStream oos = new ObjectOutputStream(fos);
       ) {
           //往文件里面写入一个int类型的整数100，占四个字节
           /*oos.writeInt(100);
           oos.writeInt(200);

           oos.writeByte(10);
           oos.writeChar('a');
           oos.writeShort(20);
           oos.writeFloat(1.23f);
           oos.writeDouble(12.34);
           oos.writeUTF("你!");
           oos.writeUTF("你好");
           oos.writeUTF("很高兴");*/

           List<Student> list = new ArrayList<>();
           for (int i=1;i<=100;i++){
               list.add(new Student("张三","男",18));
           }
           oos.writeObject(new Student("张三","男",18));
           oos.writeObject(new Student("李四","女",20));
           oos.writeObject(new Student("王五","男",19));
           oos.writeObject(list);
       } catch (IOException e) {
           e.printStackTrace();
       }

   }


public static void main(String[] args) {

       try (
               FileInputStream fis = new FileInputStream("(文件路径)");
               ObjectInputStream ois = new ObjectInputStream(fis);
       ) {

//            System.out.println(ois.readInt());
//            System.out.println(ois.readInt());
//            System.out.println(ois.readLong());
//            System.out.println(ois.readUTF());
//            System.out.println(ois.readUTF());
//            System.out.println(ois.readUTF());
           System.out.println(ois.readObject());
           System.out.println(ois.readObject());
           System.out.println(ois.readObject());
           List<Student> list = (List<Student>) ois.readObject();
           list.forEach(System.out::println);//遍历集合，jdk1.8 lambda表达式写法

       } catch (FileNotFoundException e) {
           e.printStackTrace();
       } catch (IOException e) {
           e.printStackTrace();
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       }

   }

Properties类

在这里插入图片描述 .load() 记载文件，读文件
.store() 存储文件，写入文件

public static void main(String[] args) {
       Properties p = new Properties();
       try {
           //记载文件，读文件
           p.load(new BufferedReader(new FileReader(文件路径)));
           p.put("cn","中文");
           p.put("en","英文");
           //存储文件，写入文件
           p.store(new BufferedWriter(new FileWriter(文件路径)),"test");
       } catch (IOException e) {
           e.printStackTrace();
       }
   }

多线程

线程与进程

线程与进程的区别
在这里插入图片描述 线程与多线程
多线程注意点

Java实现多线程的方式
1、继承Threa
重写run方法，线程要做的的事情都写在run方法中，run方法执行结束后，线程正常自行结束
2、实现Runnable接口
重写run方法

run() 执行体
.start() 新增线程进入就绪状态
Thread.currentThread() 返回当前正在运行得线程
.interrupt() 中断线程
.isInterrupted() 判断是否中断
Thread.sleep() 当前线程睡眠指定得一段时间（毫秒）

synchronized同步锁

用在方法上
保证线程同步，作用在方法上，此方法同一时刻只允许一个线程执行,同步方法，效率不高

public synchronized void test(){
    }

同步代码块
给一段代码上锁，锁可以是任何对象，但是必须是多个线程共同拥有的对象，即多个线程拥有同一把锁，这样才可以起到互斥作用
代码块同时只能被一个线程执行
this指当前对象锁

synchronized (this){
    }

volatile修饰词，变量值发生改变后对其他线程可见
可保证可见性、有序性
1、可见性
2、有序性
3、原子性
synchronized保证有序性、原子性

定时器和网络编程

定时器

定时器
设定任务触发时间规则，可以绑定多个定时任务
定时任务
具体要执行的任务，一个定时任务是一个线程

1、指定延迟时间后执行
2、指定时间点执行
3、指定延迟时间后执行，每隔n秒间隔执行
4、指定时间点执行，每隔n秒间隔执行

 public static void main(String[] args) {

       ///创建一个定时器对象
       Timer timer = new Timer();

       //在定时器上绑定定时任务，延迟3秒后执行定时任务，定时任务使用TimerTask创建，该类是一个线程类，实现Runnable接口，只需要重写run方法
       timer.schedule(new TimerTask() {
           @Override
           public void run() {
               System.out.println("3秒后定时任务执行");
           }
       },3000);

       //定时器绑定在一个指定时间点执行定时任务
       Calendar c = Calendar.getInstance();
       c.set(2021,6,2,10,56);
       timer.schedule(new TimerTask() {
           @Override
           public void run() {
               System.out.println("2021/7/29 10:42");
           }
       },c.getTime());

       //定时器绑定一个延迟3秒执行，每隔1秒间隔执行
       timer.schedule(new TimerTask() {
           @Override
           public void run() {
               System.out.println("延迟3秒执行，每个1秒执行一次");
           }
       },3000,1000);

       //定时器绑定一个指定时间点，每隔1秒间隔执行一次
       timer.schedule(new TimerTask() {
           @Override
           public void run() {
               System.out.println("2021/7/29 10:49 每个一秒执行一次");
           }
       },c.getTime(),1000);

       //取消定时器，绑定在定时器上的所有任务都取消，如果要取消单个任务，则调用定时任务对象的cancel
       timer.cancel();
   }

Socket编程和IO处理

TCP
可靠，传输大小无限制，但是需要连接建立时间，差错控制开销大。
UDP
不可靠，差错控制开销较小，传输大小限制在64K以下，不需要建立连接

Socket
一个Socket由一个IP地址和一个端口号唯一确定。
在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。

Socket通讯的过程
对于一个功能齐全的Socket，都要包含以下基本结构，其工作过程包含以下四个基本的步骤：
　　（1）创建Socket；
　　（2）打开连接到Socket的输入/出流；
　　（3）按照一定的协议对Socket进行读/写操作；
　　（4）关闭Socket.

客户端
public static void main(String[] args) {

        //创建一个Socket对象，用来和服务器端的Socket进行通信，传递数据
        //指定要连接的Socket端的服务器ip地址和端口号，本机IP是127.0.0.1或者写本机域名localhost
        // 如果连接成功，返回本机的一个Socket
        try (Socket s = new Socket("127.0.0.1", 8000);
             //打开输入流，用来接收服务器端发送过来的数据
             InputStream is = s.getInputStream();
             //打开输出流，用来向服务器端发送数据
             OutputStream os = s.getOutputStream();
             //封装输入流
             BufferedReader br = new BufferedReader(new InputStreamReader(is));
             //封装输出流
             PrintWriter pw = new PrintWriter(os);
             ) {

            //获取服务器发送过来的数据
            String msg = br.readLine();
            System.out.println("服务器：" + msg);

            Scanner scanner = new Scanner(System.in);
            while (true){
                //读取服务器发送过来的数据
                System.out.println("服务器："+br.readLine());
                //向服务器发送输入的数据
                String str = scanner.next();
                pw.println(str);
                pw.flush();
            }   
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

服务器端
public static void main(String[] args) {

        System.out.println("服务器开启成功！\n等待客户端连接");
        try (
                //创建服务端ServerSocket对象，指定端口接收客户端请求
                ServerSocket ss = new ServerSocket(8000);
                //监听客户端发送的请求，该方法阻塞的，如果没有客户端发来请求，一直是等待，直到有客户端发来请求返回Socket对象
                Socket s = ss.accept();
                //打开输入流，读取从客户端发来的数据
                InputStream is = s.getInputStream();
                //打开输出流，向客户端发送数据
                OutputStream os = s.getOutputStream();
                //封装输入流
                BufferedReader br = new BufferedReader(new InputStreamReader(is));
                //封装输出流
                PrintWriter pw = new PrintWriter(os);
        ) {

            System.out.println("客户端连接服务器成功！");
            //服务器端给客户端发送休息
            pw.println("欢迎访问服务器");
            //刷新缓冲区，把数据即使传输到对方
            pw.flush();

            //获取键盘输入对象
            Scanner scanner = new Scanner(System.in);
            while (true){
                //获取键盘输入的内容
                String str = scanner.next();
                //发送输入的内容到客户端
                pw.println(str);
                pw.flush();

                //接受客户端发送过来的数据
                String msg = br.readLine();
                System.out.println("客户端："+msg);
            }          
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

Socket、IO流、线程结合

/**
 * 接受信息线程
 */
public class ReceiveMsgThread implements Runnable{

    private Socket s;
    private String name;

    public ReceiveMsgThread() {
    }

    public ReceiveMsgThread(Socket s,String name) {
        this.s = s;
        this.name = name;
    }


    @Override
    public void run() {
        try (
                InputStream is = s.getInputStream();
                BufferedReader br = new BufferedReader(new InputStreamReader(is));
        ) {
            while (true){
                System.out.println(name+"说："+br.readLine());
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}



/**
 * 发送信息
 */
public class SendMsgThread implements Runnable{
    /**
     * 发送消息的Socket
     */
    private Socket s;

    public SendMsgThread(){

    }

    public SendMsgThread(Socket s){
        this.s=s;
    }

    @Override
    public void run() {
        try (
                //打开输出流，向对方Socket发送信息
                OutputStream os = s.getOutputStream();
                //封装输出流
                PrintWriter pw = new PrintWriter(os);
        ) {

            //获取键盘输入内容
            Scanner scanner = new Scanner(System.in);
            while (true) {
                //获取键盘输入的内容
                String str = scanner.nextLine();
                //发送输入的内容
                pw.println(str);
                pw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
            try {
                Socket s = new Socket("192.168.3.16", 8008);
                //创建并开启发送信息线程
                new Thread(new SendMsgThread(s)).start();
                //创建并开启1接受信息线程
                new Thread(new ReceiveMsgThread(s,"服务端")).start();

            } catch (UnknownHostException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
    }
}



/**
 * 服务器端
 */
public class Server {
    public static void main(String[] args) {

        System.out.println("服务器开启成功");
        try(
                ServerSocket ss = new ServerSocket(8000);
        ){
            while (true){
                Socket s = ss.accept();
                System.out.println("客户端连接成功！");
                new Thread(new SendMsgThread(s)).start();
                new Thread(new ReceiveMsgThread(s,"客户端")).start();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

Datagram通讯

了解

public class Client {
    public static void main(String[] args) {
        try (DatagramSocket s = new DatagramSocket()) {
            String str = "大家好！";
            //把字符串str封装到数据报中，发送给ip为127.0.0.1主机上，端口为8000
            DatagramPacket p = new DatagramPacket(str.getBytes(),str.getBytes().length, InetAddress.getByName("127.0.0.1"),8000);
            //发送数据报
            s.send(p);
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


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

        //创建一个数据报套接字，绑定端口，用来接受或者发送用户数据报
        try (
                DatagramSocket ds = new DatagramSocket(8000)
        ) {

            byte[] b= new byte[1024];
            //创建数据报，用来封装客户端发送过来的数据，指定接收数据的数组以及长度
            DatagramPacket p = new DatagramPacket(b,b.length);
            //接收数据存入数据报，如果没有收到数据报，该方法是阻塞的，直到收到数据才继续执行
            ds.receive(p);
            //获取接收到的数据
            byte[] data = p.getData();
            //转换成字符串
            System.out.println("客户端："+new String(data,0,data.length));
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

反射

获取Class类对象的三种方法
1、Class.forName(类的全限定名)
2、类名.class
3、对象名.class

各方法

.getName() 获取名称
.getSimpleName() 获取简单名
Modifier.toString(Xxx.getModifiers()) 获取修饰符

.getFields() 获取类中所有公共的属性
.getDeclaredFields() 获取类中的所由属性
.getType().getSimpleName() 获取属性类型

.getMethods() 获取类中所有的公共方法，以及父类的公共方法
.getDeclaredMethods() 获取类中所以方法，不包括父类方法
.getReturnType() 获取方法返回值
.getParameters() 获取方法中的所以参数

.getConstructors() 获取类中所有公共的构造方法
.getDeclaredConstructors() 获取类中所以的构造方法
.getParameters() 获取方法的所以参数

 public static void main(String[] args) throws Exception {

        Class<?> c = Class.forName("com.entor.test4.Student");

        //使用反射方法创建类的对象
        Constructor<?> constructors = c.getConstructor(String.class, String.class, int.class);
        Student s =(Student) constructors.newInstance(new Object[]{"张三","男",18});
        System.out.println(s);

        //使用反射方式对应对象的方法，获取返回值
        Method getName = c.getDeclaredMethod("getName");
        System.out.println(getName.invoke(s));

        Method setName = c.getDeclaredMethod("setName", String.class);
        //设置私有方法访问
        setName.setAccessible(true);
        setName.invoke(s,"李四");
        System.out.println(s);


        //使用反射方法获取对象属性
        Field name = c.getDeclaredField("name");
        //设置私有属性可访问
        name.setAccessible(true);
        name.set(s,"王五");//给s对象中name属性赋值
        System.out.println(s);
    }

public static void main(String[] args) throws Exception {

        //获取任何一个类的Class类对象的三种方法
        //方式一
        Class<?> c1 = Class.forName("com.entor.test4.Student");
        //方式二
        Class<Student> c2 = Student.class;
        //方式三
        Student s = new Student();
        Class<? extends Student> c3 = s.getClass();


        /*
        //获取类的全限定名，包名，类名
        System.out.println(c1.getName());
        //获取类的简单名称
        System.out.println(c1.getSimpleName());
        */


        /*
        System.out.println("------获取类中所有公共的属性---------------------");
        //获取类中所有公共的属性
        Field[] fields = c1.getFields();
        //遍历数组中的各个属性
        Arrays.stream(fields).forEach(field -> {
            //属性修饰符
            System.out.println("属性的修饰符："+ Modifier.toString(field.getModifiers()));
            //属性类型
            System.out.println("属性类型名称："+field.getType().getSimpleName());
            //属性名称
            System.out.println("属性名称："+field.getName());
            System.out.println("*****");
        });
        System.out.println("------获取类中所有的属性--------------------------------");
        //获取类中所有的属性
        Field[] allFields = c1.getDeclaredFields();
        //遍历数组中的各个属性
        Arrays.stream(allFields).forEach(field -> {
            //属性修饰符
            System.out.println("属性的修饰符："+Modifier.toString(field.getModifiers()));
            //属性类型
            System.out.println("属性类型名称："+field.getType().getSimpleName());
            //属性名称
            System.out.println("属性名称："+field.getName());
            System.out.println("*****");
        });
        */


        /*
        System.out.println("\n--------获取类中所有的公共方法，以及父类的公共方法---------------------");
        //获取类中所有的公共方法,以及父类的公共方法
        Method[] methods = c1.getMethods();
        Arrays.stream(methods).forEach(method -> {
            System.out.println("方法的访问修饰符："+Modifier.toString(method.getModifiers()));
            System.out.println("方法返回值类型："+method.getReturnType());
            System.out.println("方法名称：" + method.getName());
            //获取方法的所有参数
            Parameter[] parameters = method.getParameters();
            Arrays.stream(parameters).forEach(parameter -> {
                System.out.println("参数的修饰词"+Modifier.toString(parameter.getModifiers()));
                System.out.println("参数类型："+parameter.getType().getSimpleName());
                System.out.println("参数名称："+parameter.getName());
            });
            System.out.println("------------------------");
        });
        System.out.println("-----------获取类中所有的方法，不包括父类的方法---------------------");
        //获取类中所有的方法,不包括父类的方法
        Method[] allmethods = c1.getDeclaredMethods();
        Arrays.stream(allmethods).forEach(method -> {
            System.out.println("方法的访问修饰符："+Modifier.toString(method.getModifiers()));
            System.out.println("方法返回值类型："+method.getReturnType());
            System.out.println("方法名称：" + method.getName());
            //获取方法的所有参数
            Parameter[] parameters = method.getParameters();
            Arrays.stream(parameters).forEach(parameter -> {
                System.out.println("参数的修饰词"+Modifier.toString(parameter.getModifiers()));
                System.out.println("参数类型："+parameter.getType().getSimpleName());
                System.out.println("参数名称："+parameter.getName());
            });
            System.out.println("----------------------");
        });
        */

        System.out.println("--------------获取类中所有公共的构造方法-------------------------------");
        //获取类中所有公共的构造方法
        Constructor<?>[] constructors = c1.getConstructors();
        Arrays.stream(constructors).forEach(constructor -> {
            System.out.println("构造方法的修饰词：" + Modifier.toString(constructor.getModifiers()));
            System.out.println("构造方法的名称："+constructor.getName());
            //获取方法的所有参数
            Parameter[] parameters = constructor.getParameters();
            Arrays.stream(parameters).forEach(parameter -> {
                System.out.println("参数的修饰词"+Modifier.toString(parameter.getModifiers()));
                System.out.println("参数类型："+parameter.getType().getSimpleName());
                System.out.println("参数名称："+parameter.getName());
            });
            System.out.println("----------------------");
        });
        System.out.println("--------------获取类中所有的构造方法-------------------------------");
        //获取类中所有的构造方法
        Constructor<?>[] allconstructors = c1.getDeclaredConstructors();
        Arrays.stream(allconstructors).forEach(constructor -> {
            System.out.println("构造方法的修饰词：" + Modifier.toString(constructor.getModifiers()));
            System.out.println("构造方法的名称："+constructor.getName());
            //获取方法的所有参数
            Parameter[] parameters = constructor.getParameters();
            Arrays.stream(parameters).forEach(parameter -> {
                System.out.println("参数的修饰词"+Modifier.toString(parameter.getModifiers()));
                System.out.println("参数类型："+parameter.getType().getSimpleName());
                System.out.println("参数名称："+parameter.getName());
            });
            System.out.println("----------------------");
        });
    }

老板来杯柠檬水

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础

Java基础标识标识符标识符是标识类名、变量名、接口名、方法名、包名的字符串标识符规则由字母、$、_、数组组成，数字不能开头大小写敏感不能使用关键字、空格、+、-和.等特殊符号true、false、null不是关键字，但也不能用作标识符数据类型基本数据类型数值型整型：byte（1个字节），short（2个字节），int（4个字节），long（8个字节）浮点类型：float（4个字节），double（8个字节）字符型：char（2个字节）布尔类型：boolean（1位）1个字节8
复制链接

扫一扫