程序猿一枚，工作小半年，对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);

}

JavaSE深层理解

JavaSE深层理解

首先 Java 到底可以做什么：

Java的分类

JavaSE

一、标识符和关键字

二、数据类型

三、运算符与表达式

四、流程控制语句

四：数组

五：面向对象

六：集合

七：IO流

八：多线程

九：网络编程

十：反射

推荐阅读更多精彩内容