JavaSE深层理解

最新推荐文章于 2021-12-11 00:35:22 发布

黄小丶平

最新推荐文章于 2021-12-11 00:35:22 发布

阅读量370

点赞数 3

文章标签： Java JavaSE

本文链接：https://blog.csdn.net/qq_37120666/article/details/99647223

版权

程序猿一枚，工作小半年，对Java的理解已经远超刚刚离开学校是的那一枚小白了。身边的学弟陆陆续续入坑，不过经常找我抱怨发牢骚总是找不到正确的方向，该朝哪个方向发展，该怎么学习。这边就抽一晚上写一下第一阶段总结，也当是巩固学习的知识吧。如果说的不够全面或者是不对的地方，还望补充与指出错误，虚心学习。

不说Java的历史了，这边直接上干货，不要把编程想太难太复杂，就把它当作是一个工具，程序员使用工具完成想要做的事情。不过当你对这个工具的理解程度达到一定的层次，使用起来就会更加得心应手了。

首先 Java 到底可以做什么：
1、大型网站，主要使用JAVA EE，最有名例子就是电子商务交易平台阿里巴巴，淘宝，京东

2、大型企业级应用，主要使用JAVA EE，比如大型企业管理系统，CRM系统，ERP系统

2.1 有关通信及网络的大型企业：移动、联通、电信、网通主要的信息化都是JAVA

2.2 有关金融行的大型企业，所有的银行、证券公司，互联网金融；

2.3 大型管理系统，如：供应链，客户管理系统，物流系统……；

3、电子政务，主要使用JAVA EE，相关的政府部门绝大多数的信息化系统是JAVA开发的；

4、游戏，很多手机游戏都是用JAVA开发的。包括大型网游的后台数据统计都是java

5、嵌入式设备及消费类电子产品，主要用 JAVA ME,无线手持设备、通信终端、医疗设备、信息家电（如数字电视、机顶盒、电冰箱）、汽车电子设备等是比较热门的Java应用领域，这方面的应用例子有中国联通CDMA 1X网络中基于Java技术的无线

6、各大旅游网站基本都是使用java做的开发

7、我们出行的交通工具的订票系统绝大部分也是使用java开发的

8、现在比较流行的大数据，最主流的大数据框架Hadoop的应用主要用Java开发。Java最大的优势之一就是它在大数据领域的地位，目前很多的大数据架构都是通过Java来完成的

Java的分类
java主要分成三个部分javaSE，javaME，javaEE。

JAVA SE是学习JAVA EE、JAVA ME的基础，也可以做本地的软件，通俗讲就是做单机版的软件；

JAVA EE主要是开发基于Web的系统，针对互联网的各种应用和大型复杂的项目给出解决方案

JAVA ME是用来开发游戏、电子设备、手机等方面的软件。

JavaSE
这一期我们主要讲的是JavaSE，是学习Java必须学习的，是最基础的。包含Java所有的基础语法知识。
一、标识符和关键字
1. 标识符

在java语言中，用来标志类名、对象名、变量名、方法名、类型名、数组名、包名的有效字符序列，称为“标识符”；
标识符由字母、数字、下划线、美元符号组成，且第一个字符不能是数字；
java语言区分大小写；
标志符命名规则：类名首字母大写，变量名和方法名采用驼峰标志法，包名全小写，常量全大写，多个单词之间用“_”隔开；

2.关键字

在java语言中，有一些专门的词汇已经被赋予了特殊的含义，不能再使用这些词汇来命名标识符，这些专有词汇，称为“关键字”；
java有50个关键字和3个保留字，均不能用来命名标识符；
true、false、null不是关键字，是保留字，但是仍不能用来命名标识符；

二、数据类型

三、运算符与表达式
算数运算符：加(+)，减(-)，乘(*)，除(/)，求余(%)
赋值运算符：=，+=，-=，*=，%=
关系运算符：>，<，>=，<=，==，!=
逻辑运算符：&&，||，！,&，|
三目运算符：(表达式) ? 值1，值2；

四、流程控制语句
条件分支语句：if语句，switch语句
循环语句：while循环，do while循环，for循环，foreach循环

四：数组
一、数组概述

数组的概念：相同数据类型元素的集合
数组的作用：用来存储基本数据类型和引用数据类型的数据

二、数组的创建及排序

publicclass TestArray {

    publicstaticvoid main(String[] args) {

        /**        * 1. 数组的初始化

        */// 1.1 数组的静态初始化int[] array1 = { 1, 3, 5, 6, 7, 2, 4, 10 };

        // 1.2 数组的动态初始化int[] array2 =newint[5];

        array2[0] = 1;

        array2[1] = 2;

        array2[2] = 7;

        array2[3] = 3;

        array2[4] = 4;

        /**        * 2. 数组的遍历

        */// 2.1 for循环打印数组for(inti = 0; i < array2.length; i++) {

            System.out.print(array2[i]);

        }

        // 2.2 foreach打印数组for(int i : array2) {

            System.out.print(i);

        }

        /**        * 3. 数组排序

        */// 3.1 冒泡排序for(inti = 0; i < array2.length; i++) {

            for(intj = i + 1; j < array2.length; j++) {

                // 1. 比较相邻元素，将较大的数冒泡if(array2[i] > array2[j]) {

                    // 2. 交换inttemp = array2[i];

                    array2[i] = array2[j];

                    array2[j] = temp;

                }

            }

        }

        for(int i : array2) {

            System.out.println(i);

        }

        // 3.2 选择排序for(inti = 0; i < array2.length; i++) {

            intmin = i;

            for(intj = i; j < array2.length; j++) {

                // 1. 找到最小的数if(array2[j] < array2[min]) {

                    // 2. 将最小的数赋值给minmin = j;

                }

            }

            // 3. 交换两个数的位置inttemp = array2[i];

            array2[i] = array2[min];

            array2[min] = temp;

        }

        for(int i : array2) {

            System.out.println(i);

        }

        // 3.3 反转排序for(inti = 0; i < array2.length / 2; i++) {

            // 将第i位元素与array2.length-1-i位元素交换inttemp = array2[i];

            array2[i] = array2[array2.length - 1 - i];

            array2[array2.length - 1 - i] = temp;

        }

        for(int i : array2) {

            System.out.println(i);

        }

        // 3.4 插入排序for(inti = 0; i < array2.length; i++) {

            intj = i;

            inttmp = array2[i];

            for(; j > 0 && tmp < array2[j - 1]; j--) {

                // 1. 将大于待排序的数向后移array2[j] = array2[j - 1];

            }

            // 2. 交换array2[j] = tmp;

        }

        for(int i : array2) {

            System.out.println(i);

        }

        }

}

数组的初始化及排序代码实现

三、Arrays工具类常用方法

import java.util.Arrays;publicclass TestArray {

    publicstaticvoid main(String[] args) {

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

        int[] array2 = {3,2};



        // 1. 排序        Arrays.sort(array2);

        for(int i : array2) {

            System.out.print(i);

        }



        // 2. 二分法查找System.out.print(Arrays.binarySearch(array2, 3));



        // 3. 数组元素比较        System.out.println(Arrays.equals(array1, array2));



        // 4. 数组元素填充Arrays.fill(array2, 1);

        for(int j : array2) {

            System.out.println(j);

        }

    }

}

五：面向对象
一、封装

核心思想：隐藏细节，保护数据安全。
1. 访问权限

五：面向对象
一、封装

核心思想：隐藏细节，保护数据安全。
1. 访问权限

在这里插入图片描述

publicclass Encapsulation {

    // 1.成员属性私有化private String name;

    private String pwd;

    // 2.提供getter和setter方法来访问public String getName() {

        return name;

    }

    publicvoid setName(String name) {

        this.name = name;

    }

    public String getPwd() {

        return pwd;

    }

    publicvoid setPwd(String pwd) {

        this.pwd = pwd;

    }

}class TestEncapsulation {

    publicstaticvoid main(String[] args) {

        Encapsulation test =new Encapsulation();

        // 3.通过setter方法设置属性值test.setName("封装");

        test.setPwd("666");

        // 4.通过getter方法获取值System.out.println("姓名：" + test.getName() + " -- 密码：" + test.getPwd());

    }

}

二、方法的重载和重写

方法的重载：方法名相同，参数列表不同

         2. 方法的重写：方法名、返回值类型、参数列表都相同，构造方法和使用final、static修饰的方法不能被重写

三、继承

核心思想：解决代码冗余，提高代码的复用性
继承关系：满足is-a的关系，父类更通用，子类更具体。

/** * 1. 将类中重复的部分提取成为父类

*/publicclass Animal {

    private String name;

    private String food;

    public Animal(String name, String food) {

        this.name = name;

        this.food = food;

    }

    publicvoid eat() {

        System.out.println(name + "正在吃" + food);

    }

}/** * 2. 子类继承父类，对父类进行扩展

*/publicclassCatextends Animal {

    public Cat(String name, String food) {

        super(name, food);

    }

}publicclassDogextends Animal{

    public Dog(String name, String food) {

        super(name, food);

    }

}/** * 3. 测试

*/publicclass TestExtends{

    publicstaticvoid main(String[] args) {

        Animal cat =newCat("三三", "鱼");

        cat.eat();

        Animal dog =newDog("二哈", "香肠");

        cat.eat();

    }

}

四、多态

核心思想：提高代码可维护性和可扩展性
实现多态的三个必要条件：继承、重写、父类引用指向子类对象(向下转型)
多态的实现方式：重写、接口、抽象类和抽象方法

/** * 1. 创建动物类，定义动物吃什么的方法

*/class Animals {

    private String name;

    private String food;



    public Animals(String name, String food) {

        super();

        this.name = name;

        this.food = food;

    }

    publicvoid eat() {

        System.out.println(this.name + "会吃" +this.food);

    }

}/** * 2. 创建Cat类来实现吃的功能

*/classCatextends Animals{

    public Cat(String name, String food) {

        super(name, food);

    }

    @Override

    publicvoid eat() {

        super.eat();

    }

}/** * 3. 通过向上转型和向下转型实现多态

*/publicclass Test01 {

    publicstaticvoid main(String[] args) {

        // 向下转型Animals animals =newCat("三三", "鱼");

        animals.eat();

        // 向上转型Cat cat = (Cat) animals;

        cat.eat();

    }

}

   五、抽象类

             1. 核心思想：让代码有更强的可扩展性

特点：
1. 抽象类不能实例化对象。
如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法(具体实现)，或者声明自身为抽象类。
1. 抽象类中的抽象方法只有方法声明，没有方法体
2. 构造方法和static修饰的方法不能声明为抽象方法

/** * 1. 创建员工抽象类

*/abstractclass Employees {

    // 成员变量private String name;

    private String address;

    private Integer number;

    // 构造方法public Employees(String name, String address, Integer number) {

        System.out.println("Employees.Employees()");

        this.name = name;

        this.address = address;

        this.number = number;

    }

    // 定义信息抽象函数publicabstractvoid call();

    public String getName() {

        return name;

    }

    publicvoid setName(String name) {

        this.name = name;

    }

    public String getAddress() {

        return address;

    }

    publicvoid setAddress(String address) {

        this.address = address;

    }

    public Integer getNumber() {

        return number;

    }

    publicvoid setNumber(Integer number) {

        this.number = number;

    }

}classSalaryextends Employees {

    private Double salary;

    public Salary(String name, String address, Integer number, Double salary) {

        super(name, address, number);

        this.salary = salary;

        System.out.println("Salary.Salary()");

    }

    // 2. 重写父类的抽象方法    @Override

    publicvoid call() {

        System.out.println(super.getNumber() + "是" +super.getName() + "的电话，他住在" +super.getAddress() + "他现在的工资是" +this.salary);

    }

}publicclass Test {

    publicstaticvoid main(String[] args) {

        // 3. 抽象类的对象必须由子类去实例化Employees emp =newSalary("孙悟空", "花果山", 1234, 222.66);

        emp.call();

    }

}

六、接口

核心思想：让代码有更强的可扩展性
特点：
1. 接口不能实例化对象，没有构造方法
2. 接口中的方法只能是抽象方法，默认使用public abstract修饰
3. 接口中的变量只能是常量，默认使用public static final修饰
4. 接口支持多继承，但接口不是被继承了，而是被实现了
接口和抽象类的区别
1. 接口中的方法只能是抽象方法，而抽象类中的方法可以是普通方法，构造方法和抽象方法
2. 接口中的变量只能是常量，而抽象类中的方法可以是任意类型
3. 接口中不能含有静态代码块和静态方法，而抽象类中可以有
4. 一个类可以实现多个接口，但一个类只能继承一个抽象类

/** * 1. 创建Animal接口

*/interface Animal {

    // 定义睡觉抽象方法void sleep();

    // 定义吃饭抽象方法void eat();

}/** * 2. 创建Dog接口继承Animal接口

*/interfaceDogextends Animal {

    // 定义游泳抽象方法void swim();

}/** * 3. 创建HaShiQi接口继承Dog和Animal接口，实现多继承

*/interfaceHaShiQiextends Dog, Animal {

    // 定义拆家抽象方法void demolishedFamily();

}/** * 4. 创建测试类来实现接口，并且复写所有抽象方法

*/publicclassTestAnimalimplements HaShiQi {

    @Override

    publicvoid swim() {

        System.out.println("哈士奇会游泳");

    }

    @Override

    publicvoid sleep() {

        System.out.println("哈士奇会睡觉");

    }

    @Override

    publicvoid eat() {

        System.out.println("哈士奇喜欢吃苦瓜");

    }

    @Override

    publicvoid demolishedFamily() {

        System.out.println("哈士奇会拆家");

    }

    publicstaticvoid main(String[] args) {

        // 使用多态实例化对象HaShiQi dog =new TestAnimal();

        dog.eat();

        dog.sleep();

        dog.demolishedFamily();

        dog.swim();

    }

}

六：集合
一、集合简介

集合的主要作用是存储引用类型数据，长度可以动态的改变，解决了存储数据数量不确定的问题
二、Collection集合体系
在这里插入图片描述
一、Collection常用方法

二、不同集合的使用场景

import java.util.ArrayList;import java.util.Iterator;import java.util.List;/** * 创建学生类

*/class Student {

    // 学号private Integer id;

    // 姓名private String name;

    public Student(Integer id, String name) {

        this.id = id;

        this.name = name;

    }

    @Override

    public String toString() {

        return"Student [id=" + id + ", name=" + name + "]";

    }

}publicclass TestCollection {

    publicstaticvoid main(String[] args) {

        // 1. 创建集合存储String类型数据List list =newArrayList();

        // 2.向集合中添加元素list.add("猪猪侠");

        list.add("超人强");

        list.add("波比");

        list.add("小菲菲");

        // 3. 遍历集合

        // 3.1普通for循环String[] strArray =new String[list.size()];

        list.toArray(strArray); // 将集合转换为数组for(inti = 0; i < strArray.length; i++) {

            System.out.println(strArray[i]);

        }

        // 3.2 foreach循环for (String str : list) {

            System.out.println(str);

        }

        // 3.3 迭代器遍历Iterator iterator = list.iterator();

        while(iterator.hasNext()) {// hasNext()：判断指针后是否有下一个元素System.out.println(iterator.next());// next()：返回指针后的元素        }

        // 4. 判断集合中是否包含某元素System.out.println(list.contains("小菲菲"));// true

        // 5. 判断集合是否为空System.out.println(list.isEmpty());// false

        // 6. 清除集合中所有元素        list.clear();

        System.out.println(list.isEmpty()); // trueSystem.out.println("---------------------------------------------------");



        // 创建集合存储对象类型数据List list2 =newArrayList();

        // 向集合中添加对象类型数据list2.add(newStudent(1, "张三"));

        list2.add(newStudent(2, "李四"));

        // foreach遍历集合for (Student student : list2) {

            System.out.println(student);

        }

        // 迭代器遍历集合Iterator iterator2 = list2.iterator();

        while (iterator2.hasNext()) {

            Student student = iterator2.next();

            System.out.println(student);

        }

    }

}

Collection集合代码实现

在这里插入图片描述

在这里插入图片描述
七：IO流
一、IO流简介

流的概念：流是有起点和终点的一组有顺序的字节集合，作用是进行数据传输
流的分类：
1. 按照数据流向不同可以分为输入输出流；
2. 按照处理数据单位不同可以分为字节流和字符流
输入流和输出流的作用
1. 输入流：程序从数据源读取数据
2. 输出流：将数据从程序中写入指定文件
字节流和字符流的作用
1. 字节流：以字节为单位处理所有类型数据
2. 字符流：以字符为单位处理纯文本文件
  
  二、IO流体系
  
  三、IO流常用方法

import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;/** * 1. 文本文件复制

* @author DELL

*

*/publicclass TestIO {

    publicstaticvoid main(String[] args) {

        // 要读取的文件String src = "E:/Workspaces1/Demo/src/TestFile.java";

        // 要写入的文件String dest = "d:/test.java";

        // 1.1 一次复制一个字节        copyFile1(src, dest);

        // 1.2 一次复制一个字节数组        copyFile2(src, dest);



        // 2.1 一次复制一个字符        copyFile3(src, dest);

        // 2.2 一次复制一个字符数组        copyFile4(src, dest);

    }

    // 1. 一次复制一个字节，异常处理，手动关闭流publicstaticvoid copyFile1(String srcFileName, String destFileName) {

        FileInputStream fis =null;

        FileOutputStream fos =null;

        try {

            fis =new FileInputStream(srcFileName);

            fos =new FileOutputStream(destFileName);

            intcc = fis.read();

            while(cc != -1) {

                // 一次写入一个字节                fos.write(cc);

                // 一次写入一个字节cc = fis.read();

            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            if(fos !=null) {

                try {

                    fos.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

            if(fis !=null) {

                try {

                    fis.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

    }

    // 2. 一次复制一个字节数组，异常处理，自动关闭流publicstaticvoid copyFile2(String srcFileName, String destFileName) {

        // 自动关闭流try (

                FileInputStream fis =new FileInputStream(srcFileName);

                FileOutputStream fos =new FileOutputStream(destFileName);

                ) {

            byte[] bytes =newbyte[1024];

            intlen = fis.read(bytes);

            while(len != -1) {

                // 一次写入一个字节数组fos.write(bytes, 0, len);

                // 一次读取一个字节数组len = fis.read(bytes);

            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    // 3. 一次复制一个字符，异常处理，自动关闭流publicstaticvoid copyFile3(String srcFileName, String destFileName) {

        try (

                FileReader fr =new FileReader(srcFileName);

                FileWriter fw =new FileWriter(destFileName);

                ){

            intcc = fr.read();

            while(cc != -1) {

                // 一次写入一个字符                fw.write(cc);

                // 一次读取一个字符cc = fr.read();

            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (Exception e) {

            e.printStackTrace();

        }

    }



    // 4. 一次复制一个字符数组，异常处理，手动关闭流publicstaticvoid copyFile4(String srcFileName, String destFileName) {

        FileReader fr =null;

        FileWriter fw =null;

        try {

            fr =new FileReader(srcFileName);

            fw =new FileWriter(destFileName);

            char[] cbuf =newchar[1024];

            intlen = fr.read(cbuf);

            while(len != -1) {

                // 一次写入一个字符数组                fw.write(cbuf);

                // 一次读取一个字符数组len = fr.read(cbuf);

            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            if(fw !=null) {

                try {

                    fw.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

            if(fr !=null) {

                try {

                    fr.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

    }

}

import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.Serializable;/** * 1. 序列化和反序列化的概念

*          1. 对象序列化：把对象转换为字节序列(二进制数据)的过程

*          2. 对象反序列化：把字节序列恢复为对象的过程

*

* 2. 什么情况下需要序列化：

*          1. 将对象保存到文件或数据库中时

*          2. 使用套接字在网上传送对象时

*          3. 通过RMI传输对象时

*

* 3. 如何实现序列化

*          1. 创建类实现Serializable接口

*          2. 指定serialVersionUID序列号

*          3. 使用对象输出流(ObjectOutputStream)将对象保存到指定位置

*          4. 使用writerObject()方法将对象写入到文件中

*         

*

* 4. 哪些属性不能被序列化

*          1. 使用transient修饰的属性

*          2. 使用static修饰的属性

*         

*/// 1. 创建类实现Serializable接口classPeopleimplements Serializable {

    // 2. 指定序列号privatestaticfinallongserialVersionUID = 1L;

    // 静态字段privatestaticString id = "2019";

    // transient关键字修饰的字段privatetransient String name;



    private Integer age;

    public String getName() {

        return name;

    }

    publicvoid setName(String name) {

        this.name = name;

    }

    public Integer getAge() {

        return age;

    }

    publicvoid setAge(Integer age) {

        this.age = age;

    }

    @Override

    public String toString() {

        return"People [name=" + name + ", age=" + age + "]";

    }

}publicclass Test {

    publicstaticvoidmain(String[] args)throws FileNotFoundException, IOException, ClassNotFoundException {

        serializePeople();

        deserializePeople();

    }



    /**      * 序列化

    */publicstaticvoidserializePeople()throws FileNotFoundException, IOException {

        People p =new People();

        p.setName("张三");

        p.setAge(18);

        // 3. 使用对象输出流将对象保存到指定位置ObjectOutputStream oos =newObjectOutputStream(newFileOutputStream(newFile("D:/test.txt")));

        // 4. 将对象写入文件        oos.writeObject(p);

        System.out.println("对象序列化成功！！");

        oos.close();

    }



    /**      * 反序列化

    */publicstaticPeople deserializePeople()throws ClassNotFoundException, IOException {

        // 使用对象输入流从指定位置读取对象ObjectInputStream ois =newObjectInputStream(newFileInputStream(newFile("D:/test.txt")));

        // 读取对象People p = (People) ois.readObject();

        System.out.println("对象反序列化成功！！");

        return p;



    }

}

四、File类常用方法
在这里插入图片描述

import java.io.File;import java.io.FileFilter;import java.io.IOException;import java.text.SimpleDateFormat;publicclass TestFile {

    publicstaticvoidmain(String[] args)throws IOException {

        // 1. 构造方法指明文件路径以及格式File file =newFile("D:\\test2\\test.txt");

        File file2 =newFile("D:\\test2");

        File file3 =newFile("D:\\test3");



        // 2.1 创建一个文件        file.createNewFile();

        // 2.2 创建一个单级目录        file2.mkdir();

        // 2.3 创建一个多级目录        file3.mkdirs();



        // 3.1 判断文件或文件夹是否存在System.out.println(file.exists());// true

        // 3.2 判断是否为绝对路径System.out.println(file.isAbsolute());// true

        // 3.3 判断是否为文件System.out.println(file2.isFile());// false

        // 3.4 判断是否为目录System.out.println(file2.isDirectory());// true

        // 3.5 判断是否为隐藏文件System.out.println(file3.isHidden());// false



        // 4.1 获取文件或目录名称        System.out.println(file.getName());

        // 4.2 获取文件的绝对路径        System.out.println(file.getAbsolutePath());

        // 4.3 获取文件相对路径        System.out.println(file.getPath());

        // 4.4 获取文件父目录        System.out.println(file.getParent());

        // 4.5 获取文件大小        System.out.println(file.length());

        // 4.6 获取文件最后一次被修改时间SimpleDateFormat sdf =newSimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String updateTime = sdf.format(file.lastModified());

        System.out.println(updateTime);



        // 5.1 返回此目录下的所有文件和目录String [] fileString = file2.list();

        for (String str : fileString) {

            System.out.println(str);

        }

        // 5.2 返回此目录下的所有文件File [] files = file2.listFiles();

        for (File file4 : files) {

            System.out.println(file4.getName());

        }

        // 5.3  返回所有根目录File [] files2 = File.listRoots();

        for (File file4 : files2) {

            System.out.println(file4);

        }

        // 5.4 返回指定目录中符合过滤条件的文件和目录File [] files3 = file2.listFiles(new FileFilter() {



            @Override

            publicboolean accept(File pathname) {

                while("a.txt".equals(pathname.getName())){

                    returntrue;

                }

                returnfalse;

            }

        });

        for (File file4 : files3) {

            System.out.println(file4.getName());

        }

    }

}

八：多线程
一、线程相关概念

线程和进程
1. 进程：操作系统中的应用程序，一个进程就是一个应用程序
2. 线程：CPU调度的最小单元，进程的一个执行流
上下文切换
1. 上下文切换：CPU从一个线程或进程切换到另一个进程或线程；
2. 多线程程序并不是同时进行的，由于CPU的执行速度太快，CPU会在不同的线程之间快速的切换执行；
  
  二、多线程的三种实现方式及优缺点

mport java.util.concurrent.Callable;import java.util.concurrent.FutureTask;/** * 1. 创建多线程的三种方式

*        1. 继承Thread类

*       

*        2. 实现Runnable接口

*            1. 方式一：创建类实现Runnable接口

*                    1. 创建类实现Runnable接口

*                    2. 重写run()方法

*                    3. 使用Thread类的构造方法实例化实现Runnable接口的类对象

*                    4. 开启线程

*             

*            2. 方式二：使用匿名内部类

*                    1. 使用Thread类的构造方法创建一个Runnable接口的代理对象

*                    2. 重写run()方法

*                    2. 开启线程

*                   

*        3. 实现Callable接口

*              1. 方式一：创建类实现Callable接口

*                    1. 创建类实现Callable接口

*                    2. 重写call()方法

*                    3. 使用Thread类的构造方法实例化FutureTask对象

*                    4. 使用FutureTask类的构造方法实例化实现了Callable接口的类对象

*                    5. 开启线程

*             

*              2. 方式二：使用匿名内部类

*                    1. 使用Thread类的构造方法实例化FutureTask对象

*                    2. 使用FutureTask类的构造方法创建Callable接口的代理对象

*                    3. 重写call()方法

*                    4. 开启线程

*                   

* 2. 三种方式的优缺点

*        1. 继承了Thread类

*            1. 优点：代码书写简单

*            2. 缺点：由于Java的单继承性，代码的耦合度比较高

*           

*        2. 实现了Runnable接口和Callable接口

*            1. 方式一：

*                1. 优点：代码的可扩展性更强

*                2. 缺点：没有缺点

*               

*            2. 方式二：

*                1. 优点：代码书写简单

*                2. 缺点：只适合线程使用一次的时候

*//** * 1. 继承Thread类

*/classThread1extends Thread{

    publicstaticvoid test() {

        for(inti = 0; i < 100; i++) {

            System.out.println("继承Thread类执行的第" + i + "次");

        }

    }

}/** * 2. 实现Runnable接口

*/classThread2implements Runnable{

    @Override

    publicvoid run() {

        for(inti = 0; i < 100; i++) {

            System.out.println("实现Runnable接口方式一执行的第" + i + "次");

        }

    }

}/** * 3. 实现Callable接口

*/classThread3implementsCallable{

    @Override

    publicInteger call()throws Exception {

        inti = 0;

        for(; i < 100; i++) {

            System.out.println("实现Callable接口方式一执行的第" + i + "次");

        }

        return i;

    }

}publicclass TestThread {

    publicstaticvoid main(String[] args) {

        // 1. 测试继承Thread类Thread1 thread1 =new Thread1();

        thread1.start();

        Thread1.test();





        // 2. 测试实现Runnable接口

        // 2.1 方式一newThread(new Thread2()).start();



        // 2.2 方式二newThread(new Runnable() {

            @Override

            publicvoid run() {

                for(inti = 0; i < 100; i++) {

                    System.out.println("实现Runnable接口方式一执行的第" + i + "次");

                }

            }

        }).start();





        // 3. 测试实现Callable接口

        // 3.1 方式一newThread(newFutureTask(new Thread3() {

        }), "方式三").start();;



        // 3.2 方式二newThread(newFutureTask(newCallable() {

            @Override

            publicInteger call()throws Exception {

                inti = 0;

                for(; i < 100; i++) {

                    System.out.println("实现Runnable接口方式二执行的第" + i + "次");

                }

                return i;

            }

        })).start();;

    }

}

三、多线程常用方法
在这里插入图片描述

publicclass TestThreadMethod {

    publicstaticvoid main(String[] args) {

        Thread thread =newThread(new Runnable() {

            @Override

            publicvoid run() {

                for(inti = 0; i < 100; i++) {

                    // 获取正在执行的线程对象的引用System.out.println(Thread.currentThread().getName() + "执行的第" + i + "次");

                }

            }

        });

        // 1. 开启线程        thread.start();





        // 2. 设置

        // 2.1 设置该线程名称thread.setName("线程1号");

        // 2.2 设置该线程为守护线程：main方法结束之后该线程停止

        //thread.setDaemon(true);

        // 2.3 设置该线程的优先级thread.setPriority(7);





        // 3. 获取

        // 3.1 获取线程名称System.out.println(thread.getName());// 线程1号

        // 3.2 获取线程标识符System.out.println(thread.getId());// 13

        // 3.3 获取线程优先级System.out.println(thread.getPriority());// 7

        // 3.4 获取线程状态System.out.println(thread.getState());// RUNNABLE

        // 3.5 获取线程所在线程组System.out.println(thread.getThreadGroup());// java.lang.ThreadGroup[name=main,maxpri=10]





        // 4. 判断

        // 4.1 判断线程是否中断System.out.println(thread.isInterrupted());// false

        // 4.2 判断线程是否为活动状态System.out.println(thread.isAlive());// true

        // 4.3 判断线程是否为守护线程System.out.println(thread.isDaemon());// false





        // 5. 停

        // 5.1 让线程休眠指定毫秒数newThread(new Runnable() {

            @Override

            publicvoid run() {

                for(inti = 0; i < 50; i++) {

                    System.out.println(Thread.currentThread().getName() + "执行的第" + i + "次");

                    if(i == 25) {

                        try {

                            /**                            * 1. sleep()是静态方法

                            * 2. sleep()使用时必须捕获异常

                            * 3. sleep()执行时，只是让该线程进入阻塞状态，并不会释放锁

                            */                            System.out.println("线程2号正在休眠");

                            Thread.sleep(5000);

                        } catch (InterruptedException e) {

                            e.printStackTrace();

                        }

                    }

                }

            }

        },"线程2号").start();



        // 5.2 暂停当前线程去执行其他线程newThread(new Runnable() {

            @Override

            publicvoid run() {

                for(inti = 0; i < 50; i++) {

                    System.out.println(Thread.currentThread().getName() + "执行了" + i + "次");

                    if(i == 25) {

                        /**                        * 1. yield()是静态方法

                        * 2. yield()执行时，让线程进入就绪状态，重新争抢CPU执行权，并不会释放锁

                        */                        Thread.yield();

                    }

                }

            }

        },"线程3号").start();



        // 5.3 等待线程销毁newThread(new Runnable() {

            @Override

            publicvoid run() {

                for(inti = 0; i < 100; i++) {

                    if(i == 50) {

                        /**                        * 1. join()是对象方法

                        * 2. join()使用时必须捕获异常

                        * 3. join()使用场景：一个执行完的线程需要另一个正在执行的线程的运行结果时

                        */                        System.out.println("线程1号正在销毁！！！！");

                        try {

                            thread.join();

                        } catch (InterruptedException e) {

                            e.printStackTrace();

                        }

                        System.out.println("线程1号销毁成功！！！！");

                    }

                }

            }

        }
        ("线程4号").start();



    }

}

四、线程同步

import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * 1. 线程安全

*        1. 什么是线程安全：当多个线程同时操作同一共享数据时，导致共享数据出错

*        2. 怎样解决：使用线程同步技术

*       

* 2. 线程同步：将多个线程的数据共享

*

* 3. 实现线程同步的方式

*        1. 同步代码块：有synchronized关键字修饰的语句块

*                1. 实例代码块：锁对象是this或者任意对象

*                2. 静态代码块：锁对象是当前类的字节码文件

*               

*        2. 同步方法: 有synchronized关键字修饰的方法

*                1. 实例方法

*                2. 静态方法

*               

*        3. 使用重入锁

*                1. 声明锁对象

*                2. 给共享数据上锁

*                3. 在finally中解锁

*               

*        4. wait()和notify()

*                wait(): 线程等待，释放锁

*                notify(): 唤醒等待状态线程

*/class Bank{

    // 实例账户privateInteger account1 = 100;

    // 静态账户privatestaticInteger account2 = 100;

    // 1. 声明锁对象privateLock lock =new ReentrantLock();







    /**    * 1. 同步代码块

    */// 存钱1publicvoid save1(Integer money) {

        // 实例代码块synchronized(this) {

            account1 += money;

        }

        System.out.println(Thread.currentThread().getName() + "存入了" + money + "元");

    }

    // 取钱1publicvoid draw1(Integer money) {

        // 实例代码块synchronized(this) {

            if(account1 - money < 0) {

                System.out.println("账户余额不足");

                return;

            }

            account1 -= money;

            System.out.println(Thread.currentThread().getName() + "取出了" + money + "元");

        }

    }

    // 存钱2publicstaticvoid save2(Integer money) {

        // 静态代码块synchronized(Bank.class) {

            account2 += money;

        }

        System.out.println(Thread.currentThread().getName() + "存入了" + money + "元");

    }

    // 取钱2publicstaticvoid draw2(Integer money) {

        // 静态代码块synchronized(Bank.class) {

            if(account2 - money < 0) {

                System.out.println("余额不足");

                return;

            }

            account2 -= money;

            System.out.println(Thread.currentThread().getName() + "取出了" + money + "元");

        }

    }



    /**    * 2. 同步方法

    */// 2.1 实例方法publicsynchronizedvoid save3(Integer money) {

        account1 += money;

        System.out.println(Thread.currentThread().getName() + "存入了" + money + "元");

    }

    publicsynchronizedvoid draw3(Integer money) {

        if(account1 - money < 0) {

            System.out.println("余额不足");

            return;

        }

        account1 -= money;

        System.out.println(Thread.currentThread().getName() + "取出了" + money + "元");

    }



    // 2.2 静态方法publicsynchronizedstaticvoid save4(Integer money) {

        account2 += money;

        System.out.println(Thread.currentThread().getName() + "存入了" + money + "元");

    }

    publicsynchronizedstaticvoid draw4(Integer money) {

        if(account2 - money < 0) {

            System.out.println("余额不足");

            return;

        }

        account2 -= money;

        System.out.println(Thread.currentThread().getName() + "取出了" + money + "元");

    }





    /**    * 3. 重入锁

    */publicvoid save5(Integer money) {

        // 2. 上锁        lock.lock();

        try {

            account1 += money;

            System.out.println(Thread.currentThread().getName() + "存入了" + money + "元");

        } finally {

            // 3. 解锁            lock.unlock();

        }

    }

    publicvoid draw5(Integer money) {

        // 2. 上锁        lock.lock();

        try {

            if(account1 - money < 0) {

                System.out.println("余额不足");

                return;

            }

            account1 -= money;

            System.out.println(Thread.currentThread().getName() + "取出了" + money + "元");

        } finally {

            // 3. 解锁            lock.unlock();

        }

    }



    // 查看账户余额publicvoid show() {

        System.out.println("实例账户余额" + account1);

        System.out.println("静态账户余额" + account2);

    }



}classDemoimplements Runnable{

    privatestaticBank bank =new Bank();

    @Override

    publicvoid run() {

        /**        * 1. 测试同步代码块

        */// 1.1 实例代码块bank.save1(100);

        bank.show();

        bank.draw1(20);

        bank.show();



        // 1.2 静态代码块Bank.save2(100);

        bank.show();

        Bank.draw2(20);

        bank.show();



        /**        * 2. 测试同步方法

        */// 2.1 实例方法bank.save3(100);

        bank.show();

        bank.draw3(20);

        bank.show();

        // 2.2 静态方法Bank.save4(100);

        bank.show();

        Bank.draw4(20);

        bank.show();



        /**        * 3. 测试重入锁

        */        bank.save5(100);

        bank.show();

        bank.draw5(20);

        bank.show();

    }       

}publicclass TestSynchronized {

    publicstaticvoid main(String[] args) {

        // 1. 测试同步实例代码块newThread(newDemo(),"线程1号").start();

        // 2. 测试同步静态代码块newThread(newDemo(),"线程2号").start();



        // 2. 测试同步方法

        // 2.1 实例方法newThread(newDemo(),"线程3号").start();

        // 2.2 静态方法newThread(newDemo(),"线程4号").start();



        // 3. 测试冲入锁newThread(newDemo(),"线程5号").start();



    }

}

五、线程控制(线程状态转换图)
在这里插入图片描述
九：网络编程
一、网络编程概述

计算机网络：多台算机之间实现信息传递和资源共享的的计算机系统
网络编程：不同计算机之间使用网络进行数据交换

二、网络编程三要素

IP：每个设备在网络中的唯一标识
端口号：每个程序在设备上的唯一标识
协议：在网络中进行数据交换要遵守的规则

三、 UDP与TCP的区别

UDP：面向无连接，数据不可靠，速度快，适用于高速传输和对实时性要求较高
TCP：面向连接，数据可靠，速度略低，适用于可靠传输

四、网络编程常用方法
在这里插入图片描述
五、UDP传输

import java.io.IOException;import java.net.DatagramPacket;import java.net.DatagramSocket;import java.net.SocketException;/** * 1. 服务器端实现步骤

*      1. 创建服务器对象

*      2. 将接受到的数据打包

*      3. 将数据包存储到服务器对象

*      4. 打印数据

*      5. 关闭流通道

*     

* 2. 客户端步骤实现

*      1. 创建客户端对象

*      2. 将数据打包

*      3. 发送数据包

*      4. 关闭流通道

*     

* @author 萌萌哥的春天

*

*//** * 服务器端

*/publicclass Server {

    publicstaticvoidmain(String[] args)throws IOException {

        // 1. 创建服务器对象DatagramSocket ds =newDatagramSocket(9102);



        // 2. 将接收到的数据打包byte[] bytes =newbyte[1024];

        DatagramPacket dp =new DatagramPacket(bytes, bytes.length);



        // 3. 将数据包存入服务器对象        ds.receive(dp);



        // 4. 打印数据String IP = dp.getAddress().getHostAddress();// IP地址intport = dp.getPort();

        String data =newString(dp.getData(), 0, dp.getLength());// 将字节数组转为字符串System.out.println(IP+": --" + data + "--" + port + ":");



        // 5. 关闭流通道        ds.close();

    }

}/** * 客户端

*/publicclass Client {

    publicstaticvoidmain(String[] args)throws IOException {

        // 1. 创建客户端对象DatagramSocket ds =new DatagramSocket();



        // 2. 将数据打包BufferedReader br =newBufferedReader(newInputStreamReader(System.in));// 接受键盘输入byte[] bytes = br.toString().getBytes();// 将字符串转换为字节数组DatagramPacket dp =newDatagramPacket(bytes, bytes.length, InetAddress.getByName("localhost"),9102);



        // 3. 发送数据包        ds.send(dp);



        // 4. 关闭流通道        ds.close();

    }

}

六、TCP传输

/** * 1. 服务器端实现步骤

*      1. 创建服务器对象

*      2. 侦听客户端连接

*      3. 使用输入流读取客户端输入

*      4. 使用输出流写入文件

*      5. 使用输出流通知客户端

*      6. 关闭流通道

*     

* 2. 客户端步骤实现

*      1. 创建客户端对象

*      2. 使用输出流发送数据到服务器

*      3. 使用输入流读取本地文件

*      4. 使用输入流接收服务器反馈并打印到控制台

*      5. 关闭流通道

*     

* @author 萌萌哥的春天

*

*/import java.io.BufferedWriter;import java.io.BufferedReader;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.io.InputStreamReader;import java.io.OutputStreamWriter;import java.net.ServerSocket;import java.net.Socket;import java.net.UnknownHostException;/** * 服务器端

*/publicclass Server {

    privatestatic ServerSocket server;

    privatestatic Socket socket;

    privatestatic InputStream in;

    privatestatic OutputStream out;

    publicstaticvoid main(String[] args) {

        try {

            // 1. 创建服务器对象server =newServerSocket(9102);

            // 2. 侦听客户端连接socket = server.accept();

            // 3. 使用输入流接收客户端输入in = socket.getInputStream();

            // 4. 使用输出流写入文件out =newFileOutputStream("D:/server.txt");

            byte[] bytes =newbyte[1024];

            intlen = 0;

            while((len = in.read(bytes)) != -1) {

                out.write(bytes, 0, len);

                out.flush();

            }

            // 5. 使用输出流通知客户端BufferedWriter bw =newBufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

            bw.write("文件上传成功");

            bw.flush();

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            // 6. 关闭流通道if(server !=null) {

                try {

                    server.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

            if(socket !=null) {

                try {

                    socket.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

            if(in !=null) {

                try {

                    in.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

            if(out !=null) {

                try {

                    out.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

    }

}/**  * 客户端

  */publicclass Client {

    privatestatic Socket socket;

    privatestatic InputStream in;



    publicstaticvoid main(String[] args) {

        try {

            // 1. 创建客户端对象socket =newSocket("localhost", 9102);

            // 2. 使用输入流发送数据到服务器OutputStream out = socket.getOutputStream();

            // 3. 使用输入流读取本地文件in =newFileInputStream("D:/client.txt");

            byte[] bytes =newbyte[1024];

            intlen = 0;

            while((len = in.read(bytes)) != -1) {

                out.write(bytes, 0, len);

            }



            // 4. 通知服务器文件已上传            socket.shutdownOutput();



            // 5. 使用输出流接收服务器反馈BufferedReader br =newBufferedReader(new InputStreamReader(socket.getInputStream()));

            System.out.println(br.readLine());



        } catch (UnknownHostException e) {

            e.printStackTrace();

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            // 6. 关闭流通道if(socket !=null) {

                try {

                    socket.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

            if(in !=null) {

                try {

                    in.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

    }

}

十：反射
一、反射概述

反射机制：动态获取类的信息和调用对象的方法的功能
反射实现：获取每个类的字节码文件，也就是Class类对象

二、反射的三种方式

/** * 反射的三种方式：推荐2和3

*      1. Object类的getClass()方法

*      2. 实体类.class

*      3. Class类的forName()方法

*/publicclass TestReflect {

    publicstaticvoid main(String[] args) {

        // 1. 方式一：getClass()方法Worker worker =new Worker();

        Class class1 = worker.getClass();

        System.out.println(class1.getName()); // Worker



        // 2. 方式二：实体类.classClass class2 = Worker.class;

        System.out.println(class1 == class2);// true



        // 3. 方式三：Class类的forName()方法try {

            Class class3 = Class.forName("Worker");

            System.out.println(class2 == class3);// true}catch (ClassNotFoundException e) {

            e.printStackTrace();

        }

    }

}

三、Class常用方法
在这里插入图片描述

import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.Method;class Worker {

    // 私有属性private Integer id;

    private String name;

    // 公共属性    Integer age;

    public Worker() {

    }

    public Worker(String name) {

        this.name = name;

    }

    protected Worker(Integer id, String name) {

        this.id = id;

        this.name = name;

    }

    private Worker(Integer id, String name, Integer age) {

        this.id = id;

        this.name = name;

        this.age = age;

    }

    // 继承方法    @Override

    public String toString() {

        return"Worker [id=" + id + ", name=" + name + ", age=" + age + "]";

    }

    // 私有方法privatevoid test() {

        System.out.println("这是私有方法");

    }

}publicclass TestReflect {

    publicstaticvoid main(String[] args) {

        // 1. 创建Class对象Class class1 = Worker.class;

        Class class2 = String.class;





        /**        *  2. 类相关操作

        */// 2.1 获取完整性类名System.out.println(class2.getName());// java.lang.String



        // 2.2 获取类名System.out.println(class2.getSimpleName());// String



        // 2.3 获取此类的包名System.out.println(class2.getPackage());// package java.lang



        // 2.4 获取当前类所继承父类的名字System.out.println(class2.getSuperclass());// class java.lang.Object



        // 2.5获取当前类实现的接口Class[] interfaces = class2.getInterfaces();

        for(Class class3 : interfaces) {

            System.out.println(class3);

            // interface java.io.Serializable

            // interface java.lang.Comparable

            // interface java.lang.CharSequence        }   





        /**        * 3. 类中属性相关操作

        */// 3.1 获取指定属性try {

            Field declaredField = class1.getDeclaredField("name");

            System.out.println(declaredField); // private java.lang.String Worker.name}catch (NoSuchFieldException e) {

            e.printStackTrace();

        } catch (SecurityException e) {

            e.printStackTrace();

        }



        // 3.2 获取所有属性Field[] declaredFields = class1.getDeclaredFields();

        for (Field field : declaredFields) {

            System.out.println(field);

            // private java.lang.Integer Worker.id

            // private java.lang.String Worker.name

            // java.lang.Integer Worker.age        }





        /**        * 4. 类中构造方法相关操作

        */// 4.1 获取参数列表匹配的构造方法try {

            Constructor declaredConstructor = class1.getDeclaredConstructor(Integer.class, String.class, Integer.class);

            System.out.println(declaredConstructor); // private Worker(java.lang.Integer,java.lang.String,java.lang.Integer)System.out.println(class1.getDeclaredConstructor(String.class));// public Worker(java.lang.String)}catch (NoSuchMethodException e) {

            e.printStackTrace();

        } catch (SecurityException e) {

            e.printStackTrace();

        }



        // 4.2 获取类中所有公共构造方法Constructor[] constructors = class1.getConstructors();

        for(Constructor constructor : constructors) {

            System.out.println(constructor);

            // public Worker(java.lang.String)

            // public Worker()        }



        // 4.3 获取类中所有构造方法Constructor[] declaredConstructors = class1.getDeclaredConstructors();

        for(Constructor constructor : declaredConstructors) {

            System.out.println(constructor);

            // private Worker(java.lang.Integer,java.lang.String,java.lang.Integer)

            // protected Worker(java.lang.Integer,java.lang.String)

            // public Worker(java.lang.String)

            // public Worker()        }



        /**        * 5. 类中方法相关操作

        */// 5.1 获取方法名和参数列表都匹配的方法try {

            Method declaredMethod = class1.getDeclaredMethod("toString");

            System.out.println(declaredMethod); // public java.lang.String Worker.toString()System.out.println(class1.getDeclaredMethod("test"));private void Worker.test()}catch (NoSuchMethodException e) {

            e.printStackTrace();

        } catch (SecurityException e) {

            e.printStackTrace();

        }



        // 5.2 获取类中所有公共方法Method[] methods = class1.getMethods();

        for (Method method : methods) {

            System.out.println(method); // 当前类方法和它所继承的类及其实现的接口中的所有公共方法        }



        // 5.3 获取当前类中所有方法Method[] declaredMethods = class1.getDeclaredMethods();

        for (Method method : declaredMethods) {

            System.out.println(method);

            // public java.lang.String Worker.toString()

            // private void Worker.test()        }



    }

}

Class类常用方法代码实现



             四、反射核心操作

import java.lang.reflect.Field;import java.lang.reflect.Method;class Worker {

    // 私有属性private Integer id;

    private String name;

    // 公共属性public Integer age;

    public Worker() {

    }

    @Override

    public String toString() {

        return"Worker [id=" + id + ", name=" + name + ", age=" + age + "]";

    }

    // 私有方法privatevoid test() {

        System.out.println("这是私有方法");

    }



    // 公共方法publicvoid show() {

        System.out.println("这是公共方法");

    }

}publicclass TestReflect {

    publicstaticvoidmain(String[] args)throws Exception {

        // 1. 创建Class对象Class class1 = Class.forName("Worker");



        // 2. 通过构造方法实例化类对象Object obj = class1.getConstructor().newInstance();



        // 3. 给公共属性设置值Field field1 = class1.getField("age");

        field1.set(obj, 18);



        // 4. 给私有属性设置值Field field = class1.getDeclaredField("name");

        field.setAccessible(true);// 解除私有限定field.set(obj, "张三");// 为Worker类中的name属性设置值



        // 5. 调用公共成员方法Method method1 = class1.getMethod("show");

        method1.invoke(obj);



        // 6. 调用私有成员方法Method method = class1.getDeclaredMethod("test");

        method.setAccessible(true);

        method.invoke(obj); // 第一个参数是类对象，其余的为实参        System.out.println(obj);

    }

}

黄小丶平

关注

3
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
JavaSE深层理解

程序猿一枚，工作小半年，对Java的理解已经远超刚刚离开学校是的那一枚小白了。身边的学弟陆陆续续入坑，不过经常找我抱怨发牢骚总是找不到正确的方向，该朝哪个方向发展，该怎么学习。这边就抽一晚上写一下第一阶段总结，也当是巩固学习的知识吧。如果说的不够全面或者是不对的地方，还望补充与指出错误，虚心学习。不说Java的历史了，这边直接上干货，不要把编程想太难太复杂，就把它当作是一个工具，程序员使用工具...
复制链接

扫一扫