程序猿一枚，工作小半年，对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. 标识符
1. 在java语言中，用来标志类名、对象名、变量名、方法名、类型名、数组名、包名的有效字符序列，称为“标识符”；
2. 标识符由字母、数字、下划线、美元符号组成，且第一个字符不能是数字；
3. java语言区分大小写；
4. 标志符命名规则：类名首字母大写，变量名和方法名采用驼峰标志法，包名全小写，常量全大写，多个单词之间用“_”隔开；
2. 关键字
1. 在java语言中，有一些专门的词汇已经被赋予了特殊的含义，不能再使用这些词汇来命名标识符，这些专有词汇，称为“关键字”；
2. java有50个关键字和3个保留字，均不能用来命名标识符；
3. true、false、null不是关键字，是保留字，但是仍不能用来命名标识符；
二、数据类型
三、运算符与表达式
1. 算数运算符：加(+)，减(-)，乘(*)，除(/)，求余(%)
2. 赋值运算符：=，+=，-=，*=，%=
3. 关系运算符：>，<，>=，<=，==，!=
4. 逻辑运算符：[&&，||](只有左侧满足才计算右侧)，！,[&，|](不管左侧结果如何，都要计算右侧)
5. 三目运算符：(表达式) ? 值1，值2；
四、流程控制语句
1. 条件分支语句：if语句，switch语句
2. 循环语句：while循环，do while循环，for循环，foreach循环
四：数组
一、数组概述
1. 数组的概念：相同数据类型元素的集合
2. 数组的作用：用来存储基本数据类型和引用数据类型的数据
二、数组的创建及排序
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);
}
}
}
Arrays工具类常用方法代码实现
五：面向对象
一、封装
1. 核心思想：隐藏细节，保护数据安全。
2. 访问权限
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());
}
}
封装代码实现
二、方法的重载和重写
1. 方法的重载：方法名相同，参数列表不同
2. 方法的重写：方法名、返回值类型、参数列表都相同，构造方法和使用final、static修饰的方法不能被重写
三、继承
1. 核心思想：解决代码冗余，提高代码的复用性
2. 继承关系：满足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. 核心思想：提高代码可维护性和可扩展性
2. 实现多态的三个必要条件：继承、重写、父类引用指向子类对象(向下转型)
3. 多态的实现方式：重写、接口、抽象类和抽象方法
/** * 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. 核心思想：让代码有更强的可扩展性
2. 特点：
1. 抽象类不能实例化对象。
2. 如果一个类包含抽象方法，那么该类必须是抽象类。
3. 任何子类必须重写父类的抽象方法(具体实现)，或者声明自身为抽象类。
4. 抽象类中的抽象方法只有方法声明，没有方法体
5. 构造方法和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. 特点：
1. 接口不能实例化对象，没有构造方法
2. 接口中的方法只能是抽象方法，默认使用public abstract修饰
3. 接口中的变量只能是常量，默认使用public static final修饰
4. 接口支持多继承，但接口不是被继承了，而是被实现了
3. 接口和抽象类的区别
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集合代码实现
三、Map集合体系
import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Map.Entry;import javax.enterprise.inject.New;class Teacher {
private String name;
private Integer age;
public Teacher(String name, Integer age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return"Teacher [name=" + name + ", age=" + age + "]";
}
}publicclass TestMap {
publicstaticvoid main(String[] args) {
// 1. 创建Map集合存储学号和姓名Map map =newHashMap();
// 2. 向map集合中添加元素map.put(1, "张三");
map.put(2, "李四");
map.put(3, "王五");
// 3. 遍历map集合
// 3.1 通过map.keySet()遍历集合for (Integer key : map.keySet()) {
System.out.println("key=" + key + " value=" + map.get(key));
}
// 3.2 通过迭代器遍历集合Iterator> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry entry = iterator.next();
System.out.println("key=" + entry.getKey() + " value=" + entry.getValue());
}
// 3.3 通过map.entrySet()遍历集合for(Entry entry : map.entrySet()) {
System.out.println("key=" + entry.getKey() + " value=" + entry.getValue());
}
// 4. 判断集合中是否包含指定键System.out.println(map.containsKey("1"));// trueSystem.out.println(map.containsValue("list"));// false
// 5. 判断集合是否为空System.out.println(map.isEmpty());// false
// 6. 清除集合中所有元素 map.clear();
System.out.println(map.isEmpty()); // trueSystem.out.println("----------------------------------------");
// 1. 创建Map集合存储对象类型数据Map map2 =newHashMap();
// 2. 向Map集合中添加对象类型数据map2.put(1,newTeacher("张三", 18));
map2.put(2,newTeacher("李四", 19));
map2.put(3,newTeacher("王五", 20));
// 3. 遍历集合
// 3.1 通过map.keySet()遍历for (Integer key : map2.keySet()) {
System.out.println("key=" + key + " value=" + map2.get(key));
}
// 3.2 通过迭代器遍历集合Iterator> iterator2 = map2.entrySet().iterator();
while (iterator2.hasNext()) {
Entry entry = iterator2.next();
System.out.println("key=" + entry.getKey() + " value=" + entry.getValue());
}
// 3.3 通过map.entrySet()遍历集合for(Entry entry : map2.entrySet()) {
System.out.println("key=" + entry.getKey() + " value=" + entry.getValue());
}
}
}
Map集合代码实现
七：IO流
一、IO流简介
1. 流的概念：流是有起点和终点的一组有顺序的字节集合，作用是进行数据传输
2. 流的分类：
1. 按照数据流向不同可以分为输入输出流；
2. 按照处理数据单位不同可以分为字节流和字符流
3. 输入流和输出流的作用
1. 输入流：程序从数据源读取数据
2. 输出流：将数据从程序中写入指定文件
4. 字节流和字符流的作用
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());
}
}
}
File类代码实现
八：多线程
一、线程相关概念
1. 线程和进程
1. 进程：操作系统中的应用程序，一个进程就是一个应用程序
2. 线程：CPU调度的最小单元，进程的一个执行流
2. 上下文切换
1. 上下文切换：CPU从一个线程或进程切换到另一个进程或线程；
2. 多线程程序并不是同时进行的，由于CPU的执行速度太快，CPU会在不同的线程之间快速的切换执行；
二、多线程的三种实现方式及优缺点
import 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();
}
}
线程同步总结及代码实现
五、线程控制(线程状态转换图)
九：网络编程
一、网络编程概述
1. 计算机网络：多台算机之间实现信息传递和资源共享的的计算机系统
2. 网络编程：不同计算机之间使用网络进行数据交换
二、网络编程三要素
1. IP：每个设备在网络中的唯一标识
2. 端口号：每个程序在设备上的唯一标识
3. 协议：在网络中进行数据交换要遵守的规则
三、 UDP与TCP的区别
1. UDP：面向无连接，数据不可靠，速度快，适用于高速传输和对实时性要求较高
2. 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();
}
}
UDP传输代码实现
六、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();
}
}
}
}
}
TCP传输代码实现
十：反射
一、反射概述
1. 反射机制：动态获取类的信息和调用对象的方法的功能
2. 反射实现：获取每个类的字节码文件，也就是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);
}
}