一:网络编程;
1. 网络编程的三要素:
(1)必须要有对应得IP地址;
(2)必须有端口号;
(3)必须有规定好的协议(TCP或者UDP)
2. IP的分类:
A类: 1.0.0.1---127.255.255.254:第一个号段为网络号段,后三个号段为主机号段
B类: 128.0.0.1---191.255.255.254:前两个号段为网络号段,后两个号段为主机号段
C类: 192.0.0.1---223.255.255.254:前三个好号段为网络号段,后一个号段为主机号段
D类: 224.0.0.1---239.255.255.254
E类: 240.0.0.1---247.255.255.254
127.0.0.1:回环地址(也可表示本机地址)
3.端口号:
(1) 有效端口号:0~65535; 保留端口号:0~1024
4协议:
TCP协议: (客户端和服务器端的交互)
1) 建立连接通道(通道内的流:(使用的是最基本的字节流))
2) 可靠协议
3) 由于可靠协议,并且需要建立连接通道,(服务器端需要等待客户端的连接),所以执行效率低
4) 使用TCP协议编程,可以发送大量的数据,文件大小五限制
UDP协议(发送方和接收方的交互)
(1)无需建立通道,(以数据报包的形式发送数据)
(2)不可靠协议
(3)由于不可靠协议,无需建立通道,所以执行效率高
(4)UDP协议编程发送数据有限制,
5.InetAddress类:该类没有构造方法; 此类表示互联网协议 (IP) 地址
如果一个类没有构造方法,
(1),该类中的方法都是静态方法,( Math,Arrays,Collections)
(2),单例模式: 在内存始终只有一个对象;
将构造方法私有化;
在成员变量创建该类的实例(并且这个实例私有化被static修身);
提供该类公共方法可以通过外界调用;
(3)该类中某些静态方法的返回值就是它本身;
6.InetAddress类的成员方法:
Public static InetAddress getByName(String host) 各类抛出异常throws UnknownHostException在给定主机名的情况下确定主机的 IP 地址
public String getHostName()获取此 IP 地址的主机名。
public String getHostAddress()返回 IP 地址字符串（以文本表现形式）
#InetAddress类中成员方法的应用:
package InetAddressText;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
* 需求:使用InetAddress的成员方法
* */
public class InetAddressText_01 {
public static void main(String[] args) throws UnknownHostException {
//调用InetAddress类的getByName()方法,获取本地的IP地址
// InetAddressaddress=InetAddress.getByName("DESKTOP-P8MER0G");//该方法的参数可以是本地计算机名称的字符串形式,也可以是IP地址的字符串形式
// System.out.println(address);
//通过IP地址获取本地计算机的名称
InetAddress address=InetAddress.getByName("10.151.4.199");
String AddressName=address.getHostName();//获取本地计算机名称
System.out.println("当前本地计算机的名称为:" + AddressName);
String HostName=address.getHostAddress();//获取计算机的IP地址,以字符串的形式显示
System.out.println("本地的IP地址为:" + HostName);
}
}
7.使用UDP协议进行编程:
1.UDP发送端步骤
(1)创建Socket对象
(2)创建数据报包对象,通过这个数据报包对象将数据发送到接收端
(3)调用UDP发送端的发送方法
(4)关闭资源
2.UDP接收端的步骤
(1)创建Socket对象
(2)创建一个数据报包来接收发送端发来的数据的数据报包
(3)用上述对象,调用接收数据的方法
(4)解析数据报包里面的数据,让其显示在空时台上
(5)关闭资源
#使用UDP协议进行编程;
接收端:
package InetAddressText;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
public class UDPReceiveText_01 {
public static void main(String[] args) throws Exception {
//创建Socket对象
DatagramSocket ds=new DatagramSocket(10086);
//创建一个数据报包来接收发送端发来的数据报包文件
byte [] bys=new byte[1024];
int len=bys.length;
DatagramPacket dp=new DatagramPacket(bys,len);
//调用接收方法
ds.receive(dp);
//将数据报包里的数据显示在控制台上
InetAddress address = dp.getAddress();
String ip = address.getHostAddress();
byte[] bs = dp.getData();
int len1=bs.length;
String Str = new String(bs, 0, len1);
System.out.println("从发送方法传过来的数据是:" + Str);
}
}
发送端:
package InetAddressText;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketException;
public class UDPText_01 {
public static void main(String[] args) throws Exception {
DatagramSocket sk=new DatagramSocket();//创建Socket对象
String Str="you arebeautiful!";
byte[] bs = Str.getBytes();
int len = bs.length;
//获取本地IP地址
InetAddress address = InetAddress.getByName("10.151.4.199");
//创建数据报包对象
DatagramPacket sp=new DatagramPacket(bs,len,address,10086);
//调用发送方法
sk.send(sp);//将该数据报包发送出去
//关闭资源
sk.close();
}
}
#使用UDP协议编程优化:
发送端:
package InetAddressText;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
/**
* 需求:优化UDP编程的代码;
* 1.在发送端创建Socket对象
* 2.定义一个字符串类型的数据源,将其转化为字节数组,并获取该字节数组的长度
* 3.创建数据报包对象,并指明其参数
* 4.调用Socket对象的Send()方法,将上述的数据报包对象当做参数进行传入
* 5.最后关闭资源
* */
public class UDPSendText_03 {
public static void main(String[] args) throws Exception {
//创建Socket对象
DatagramSocket ds=new DatagramSocket();
//定义数据源
byte [] bys="you arebeautiful!".getBytes();
//创建数据报包对象
DatagramPacket dp = new DatagramPacket(bys, bys.length,
InetAddress.getByName("10.151.4.199"), 10087);
//将该数据源发送到数据报包中
ds.send(dp);
//关闭资源
ds.close();
}
}
接收端:
package InetAddressText;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
/**
* 需求:使用接收端来接收数据
* 1.创建Socket对象,并指明其端口号
* 2.定义一个字节缓冲数组,并获取其长度
* 3.创建接收端的数据报包对象,并将上述的对象当做参数进行传入
* 4.接收数据报包里的数据
* 5.解析数据并显示在控制台上
* 6.获取数据报包中的IP地址,以字符串显示出来
* */
public class UDPReceiveText_03 {
publicstatic void main(String[] args) throws Exception {
//创建接收端的Socket对象
DatagramSocketds=new DatagramSocket(10087);
//定义一个字节缓冲区
byte[]bys=new byte[1024];
//创建数据报包对象
DatagramPacketdp=new DatagramPacket(bys,bys.length);
//调用Socket对象的Receive()方法来接收数据报包里的数据
ds.receive(dp);
//获取数据报包中的IP地址,以字符串显示出来
StringIPStr=dp.getAddress().getHostAddress();
//再定义一个字节缓冲区用来存放获取到的字节信息
byte[]bys2=dp.getData();//getData()方法返回值为字节类型
//将上述获取到的数据以字符串显示出来
intlen=dp.getLength();
Strings1 = new String(bys2, 0, len);
//打印在控制台上
System.out.println(IPStr+ "中的信息为:" + s1);
//关闭资源
ds.close();
}
}
#需求:使用UDP编程实现发送端不停地键盘录入数据,接收端不停地向控制台输出数据
发送端:
package InetAddressText;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
/**
* 需求:使用UDP编程,实现发送端不停地向接收端发送数据,并且接收端不停地输出数据
* 1.创建Socket对象,
* 2.创建BufferedReader对象,使用该对象去封装标准输入流,使用该方法来进行键盘录入,
* 3.将上述的键盘录入方法在一个while()循环中,输入完之后,再定义一个输入结束的标志
* 4.将输入的数据转换为字节类型
* 5.创建数据报包对象,并且封装数据源,IP地址以及端口号
* 6.发送数据
* 7.关闭资源
* */
public class UDPSentText_04 {
publicstatic void main(String[] args) throws Exception {
//创建发送端的Socket对象
DatagramSocketds=new DatagramSocket();
//创建键盘录入方式
BufferedReaderbr=new BufferedReader(new InputStreamReader(System.in));
Stringline=null;
while((line=br.readLine())!=null){
br.readLine();
if("end".equals(line)){
System.exit(0);
}
//将输入的字符数据转换为字节数组
byte[]bs = line.getBytes();
//创建数据报包对象
DatagramPacketdp = new DatagramPacket(bs, bs.length,
InetAddress.getByName("10.151.4.199"),23333);
//发送该数据
ds.send(dp);
}
//关闭资源
ds.close();
}
}
接收端:
package InetAddressText;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
/**
*需求:不停地接收数据报包传来的数据,并且显示在控制台上
*1.创建接收端的Socket对象
*定义一个while()循环,不停地接收发送端发来的数据
* */
public class UDPReceiveText_04 {
publicstatic void main(String[] args) throws Exception {
//创建Socket对象
DatagramSocketds=new DatagramSocket(23333);
//创建一个while()循环来不停地接收数据
while(true){
byte[]bys=new byte[1024];
//创建数据报包对象
DatagramPacketdp=new DatagramPacket(bys,bys.length);
//接收数据
ds.receive(dp);
//获取文件中的IP地址,以字符串形式显示在控制台上
StringIPStr =dp.getAddress().getHostAddress();
//获取数据报包中的实际字节缓冲大小
byte[]bys2=dp.getData();
//让其数据以字符串形式显示出来
Strings=new String(bys2,0,dp.getLength());
System.out.println(IPStr+ "传过来的数据信息为:" + s);
//关闭资源
ds.close();
}
}
}
需求:使用多线程的第二种方法,创建发送端和接收端的子实现类,让其分别实现接口Runnable,然后创建主线程,在主线程中启动发送端和接收端的线程,来实现发送端和接收端的数据互联
发送端:
package InetAddressText;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;
public class UDPSendText_05 implements Runnable {
private DatagramSocket ds;
public UDPSendText_05(DatagramSocket ds) {
super();
this.ds = ds;
}
public void run() {
try {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));//创建字符缓冲输入流,进行键盘录入
String line=null;
while((line=br.readLine())!=null){
br.readLine();
if("end".equals(line)){//定义读取结束标志
break;
}
//将上述的字符数据转换为字节数组
byte[] bs = line.getBytes();
//创建数据报包对象
DatagramPacket dp = new DatagramPacket(bs, bs.length,InetAddress.getByName("10.151.4.199"),10086);
//发送数据
ds.send(dp);
}
} catch (IOException e) {
// TODO Auto-generatedcatch block
e.printStackTrace();
} finally{
if(ds!=null){
ds.close();
}
}
}
}
接收端:
package InetAddressText;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class UDPReceiveText_05 implements Runnable {
private DatagramSocket ds;
public UDPReceiveText_05(DatagramSocket ds) {
super();
this.ds = ds;
}
public void run() {
try {
while(true){
byte[] bys=new byte[1024];
//创建数据报包对象
DatagramPacket dp=new DatagramPacket(bys,bys.length);
//接收数据报包
ds.receive(dp);
//获取数据报包中的IP地址的String表现形式
String IPStr=dp.getAddress().getHostAddress();
//获取数据的实际缓冲字节大小
byte[] bys2=dp.getData();
//让字节数组中的数据以字符串的形式打印在控制台上
String s = new String(bys2, 0, dp.getLength());
System.out.println(IPStr + "中解析出的信息为:" + s);
}
} catch (IOException e) {
// TODO Auto-generatedcatch block
e.printStackTrace();
}
}
}
主线程端:
package InetAddressText;
import java.net.DatagramSocket;
import java.net.SocketException;
/**
* 需求:使用UDP编程使发送端和接收端在一个窗口中执行,
* 1.使用多线程的第二种方式,实现Runnable接口,再创建一个主线程,
* 让其两个发送端和接收端的线程在主线程中同时执行
* 2.创建发送端的子实现类,该类实现接口Runnable,并且在其中重写run()方法,
* 在该方法中通过BufferedReader来进行键盘录入,
* 同时创建数据报包对象,将其读入的数据发送到数据报包中,
* 3.创建接收端的子实现类,该类实现接口Runnable,并且在该类中重写run()方法,
* 在该方法中,定义一个while()循环来接收发送端发来的数据
* 4.创建主线程类,在该类中首先创建发送端和接收端的Socket()对象
* */
public class UDPText_05 {
public static void main(String[] args) {
try {
//分别创建发送端和接收端Socket对象
DatagramSocket SendDs=new DatagramSocket();
DatagramSocket ReceiveDs=new DatagramSocket(10086);
//创建资源对象
UDPSendText_05 us=new UDPSendText_05(SendDs);
UDPReceiveText_05 ur=new UDPReceiveText_05(ReceiveDs);
//创建线程对象
Thread t1=new Thread(us);
Thread t2=new Thread(ur);
//执行线程
t1.start();
t2.start();
} catch (SocketException e) {
// TODO Auto-generatedcatch block
e.printStackTrace();
}
}
}
8使用TCP协议进行传输数据(客户端与服务器端)
(1)TCP协议编程的一般步骤:
客户端:a,创建Socket对象(客户端套接字流的形式)并指IP地址和端口号
B,获取通道内的输出流
C,通过输出流向服务器端写数据
D,关闭客户端的Socket对象
服务器端:a,创建Socket对象,并指明端口号
B,服务器需要监听客户端的连接
C,获取通道内的输入流
D,将数据获取到并显示在控制台上
E,关闭Socket对象
#使用TCP编程传输数据
客户端:
package TCPText;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
/**
* 需求:使用TCP编程,实现数据的传输
* 1.在客户端创建Socket对象,并指明IP地址和端口号
* 2.创建通道内的输出流,用此输出流对象向服务器端写数据
* 3.关闭客户端的Socket对象
* */
public class TCPClientText_01 {
public static void main(String[] args) throws Exception, IOException {
//创建客户端的Socket对象
Socket s=new Socket(InetAddress.getByName("10.151.4.199"),10089);
//创建通道内的输出流
OutputStream ous=s.getOutputStream();
//通过上述的输出流对象向服务器端写数据
ous.write("this is mylife!".getBytes());
//关闭Socket对象
s.close();
}
}
服务器端:
package TCPText;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 1.创建Socket对象,并指明端口号
* 2.服务器监听客户端的连接
* 3.创建通道内的输入流
* 4.将数据获取到并显示在控制台上
* 5.关闭Socket资源
* */
public class TCPServerText_01 {
public static void main(String[] args) throws Exception {
//创建服务器端Socket对象
ServerSocket ss=new ServerSocket(10089);
//服务器监听客户端连接
Socket ap = ss.accept();
//创建通道内的输入流
InputStream is = ap.getInputStream();
//获取通道内的IP地址的字符串表现形式
String IPStr = ap.getInetAddress().getHostAddress();
//将获取到的通道内的数据显示在控制台上
byte[] bys=new byte[1024];
//获取到该字节数组的实际长度
int len = is.read(bys);
String s = new String(bys, 0, len);
System.out.println(IPStr + "解析后的数据信息为:" + s);
//关闭Socket资源
ss.close();
}
}
#TCP编程实现客户端和服务器端的互相反馈
客户端：
packageTCPText_01;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.net.Socket;
import java.net.UnknownHostException;
/**
* 需求：使用TCP编程，实现用户端和客户端互相反馈
* 1.在用户端创建Socket对象，并指明IP地址和端口号
* 2.创建通道内的输出流，将写好的数据发送到通道内，
* 3.为了通过反馈显示到服务器端已经接受到数据，需要创建通道内的输入流，并将结果显示在控制台上
* 4.关闭Socket对象资源
* */
public class Client_01 {
public static void main(String[] args) throws IOException {
//创建Socket对象
Socket s=new Socket("10.151.4.199",10086);
//创建通道内的输出流
OutputStream ClientOps =s.getOutputStream();
//向通道内写数据,并发送到服务器端
ClientOps.write("This is Client!".getBytes());
//服务器端向客户端反馈,需要创建通道内的输入流,
InputStream ClientIs =s.getInputStream();
//将反馈过来的数据显示在控制台上
byte[] bys=new byte[1024];
int len=ClientIs.read(bys);
//获取该数据的字符串形式
String ClientStr = new String(bys, 0, len);
System.out.println("ClientStr:" + ClientStr);
//关闭资源
s.close();
}
}
服务器端：
packageTCPText_01;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.net.ServerSocket;
importjava.net.Socket;
/**
* 1.创建服务器端的Socket对象,并指明端口号
* 2.服务器监听客户端的请求,
* 3.创建通道内的输入流,将获取到的数据显示在控制台上,
* 4.
* */
public class Server_01 {
public static void main(String[] args) throws IOException {
//创建服务器端的Socket对象
ServerSocket ss=new ServerSocket(10086);
System.out.println("等待服务器连接!");
//服务器端监听客户端的连接
Socket s = ss.accept();//监听结束,连接上资源
System.out.println("服务器已连接.......");
//创建通道内的输入流,
InputStream ServerIs =s.getInputStream();
//并将获取到的数据显示在控制台上
byte[] bys=new byte[1024];
int len=ServerIs.read(bys);
String ServerStr = new String(bys, 0, len);
System.out.println("ServerStr:" + ServerStr);
//服务器端反馈,创建通道内的输出流
OutputStream ServerOs =s.getOutputStream();
ServerOs.write("服务器端已经成功接收到数据!".getBytes());
//关闭服务器端的Socket对象
//ss.close();
//关闭监听客户端的连接资源
s.close();
}
}
#使用TCP编程实现在客户端键盘录入数据，然后传输到服务器端
客户端：
packageTCPText_01;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.OutputStreamWriter;
importjava.net.Socket;
import java.net.UnknownHostException;
/**
* 需求:使用TCP编程实现客户端键盘录入数据,并传给服务器端
* 1.创建客户端Socket对象,并指明IP地址和端口号
* 2.创建字符缓冲输入流对象,层层封装标准输入流,
* 3.创建通道内的字节输出流,用字符缓冲输出流封装
* 4.使用字符缓冲输入流的一次读取一行的方法获取键盘录入的数据,
* 再使用字符缓冲输出流的一次写一行的方法,向通道内写数据.
* 5.最后关闭Socket资源
* */
public class Client_02 {
public static void main(String[] args) throws IOException {
//创建客户端的Socket对象
Socket s=new Socket("10.151.4.199",10087);
//创建字符缓冲输入流的对象
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入要传输的数据:");
//创建通道内的字节输出流,用字符缓冲输出流包装
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
//使用字符缓冲输入流的一次读取一行的方法,获取键盘录入的数据
String line=null;
while((line=br.readLine())!=null){
if("end".equals(line)){
break;
}
bw.write(line);
bw.newLine();
bw.flush();
}
//关闭Socket资源
s.close();
}
}
服务器端：
packageTCPText_01;
importjava.io.BufferedReader;
import java.io.IOException;
importjava.io.InputStreamReader;
importjava.net.ServerSocket;
importjava.net.Socket;
/**
*1.创建服务器端的Socket对象,并指明端口号
*2.服务器监听客户端连接
*3.创建通道内的输入流,使用字符缓冲输入流进行封装
*4.使用字符缓冲输入流的一次读取一行的方法,将通道内的数据显示在控制台上
*5.关闭资源
* */
public class Server_02 {
public static void main(String[] args) throws IOException {
//创建服务器端的Socket对象
ServerSocket ss=new ServerSocket(10087);
System.out.println("等待客户端的连接.....");
//进行服务器端监听客户端的连接
Socket s = ss.accept();
System.out.println("客户端已成功连接!");
//创建通道内的输入流,只用字符缓冲输入流进行封装
BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
//通过字符缓冲输入就得一次读取一行方法,将通道内的数据显示在控制台上
String line=null;
while((line=br.readLine())!=null){
System.out.println(line);
}
//关闭资源
s.close();
}
}
#使用TCP编程实现客户端键盘录入数据，传输到服务器端，然后写入当前项目下的文件a.txt中
客户端:
packageTCPText_01;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;
/**
* 需求:使用TCP编程,实现从客户端键盘录入数据,然后发送到服务器端,
* 最终通过服务器,将获取到的数据写在当前项目下的文件中
* 1.创建客户端的Socket对象,并指明IP地址和端口号
* 2.创建字符缓冲输入流,用该流进行层层封装标准输入流,进行键盘录入
* 3.创建通道内的字符缓冲输出流,通过字符缓冲流的一次读写一行的方法,
* 将录入的信息发送到服务器端
* 4.关闭资源
* */
public class Client_03 {
public static void main(String[] args) throws IOException {
//创建客户端的Socket对象
Socket s=new Socket("10.151.4.199",10088);
//创建进行键盘录入的字符缓冲输入流
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入要传入的数据:");
//创建通道内的自负缓冲输出流
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
s.getOutputStream()));
//将键盘读入的数据传输到服务器端
String line=null;
while((line=br.readLine())!=null){
if("end".equals(line)){
break;
}
bw.write(line);
bw.newLine();
bw.flush();
}
//关闭资源
s.close();
//bw.close();
}
}
服务器端:
packageTCPText_01;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.FileWriter;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.net.ServerSocket;
importjava.net.Socket;
/**
* 1.创建服务器端的Socket对象,并指明端口号
* 2.进行服务器监听客户端连接
* 3.创建通道内的字符缓冲输入流,
* 4.创建字符缓冲输出流,用来封装当前项目下的a.txt文件
* 5.使用字符缓冲流的一次读写一行的方法,将通道内的数据写入文件中
* 6.关闭资源
*
* */
public class Server_03 {
public static void main(String[] args) throws IOException {
//创建服务器端的Socket对象
ServerSocket ss=new ServerSocket(10088);
System.out.println("等待客户端连接..");
//进行监听客户端连接
Socket s = ss.accept();
System.out.println("客户端已连接!");
//创建通道内的输入流
BufferedReader br = new BufferedReader(new InputStreamReader(
s.getInputStream()));
//创建字符缓冲输出流,用来向当前项目下的文件a.txt中写数据
BufferedWriter bw=new BufferedWriter(new FileWriter("a.txt"));
//向文件中写数据
String line=null;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//关闭资源
s.close();
bw.close();
}
}
#使用TCP编程实现客户端从当前项目下读取文件,然后将数据发送到服务器端,最后显示在控制台上
客户端:
packageTCPText_01;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.FileReader;
importjava.io.IOException;
importjava.io.OutputStreamWriter;
importjava.net.Socket;
import java.net.UnknownHostException;
/**
* 需求:使用TCP编程,实现客户端从当前项目下的文件中获取数据,然后传输到服务器端,显示在控制台上
* 1.创建客户端的Socket对象,并指明IP地址和端口号
* 2.创建字符缓冲输入流进行封装档子按项目下的文件TCP.txt
* 3.创建通道内的字符缓冲输出流,
* 4.使用字符缓冲流的一次读写一行的方法,向服务器端发送数据
* 5.关闭资源
* */
public class Client_04 {
public static void main(String[] args) throws IOException {
//创建Socket对象
Socket s=new Socket("10.151.4.199",10089);
//创建字符缓冲输入流对象
BufferedReader br=new BufferedReader(new FileReader("TCP.txt"));
//创建通道内的字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
s.getOutputStream()));
//使用字符缓冲流的一次读写一行的方法,将改文件中的数据发送到服务器端
String line=null;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//关闭资源
s.close();
}
}
服务器端:
packageTCPText_01;
importjava.io.BufferedReader;
import java.io.BufferedWriter;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.net.ServerSocket;
importjava.net.Socket;
/**
* 1.创建服务器端的Socket对象
* 2.进行服务器监听客户端连接
* 3.创建通道内的字符缓冲输入流,获取到通道内的数据'将上述的数据显示在控制台上
* 4.关闭资源
* */
public class Server_04 {
public static void main(String[] args) throws IOException {
//创建服务器端的Socket对象
ServerSocket ss=new ServerSocket(10089);
System.out.println("等待客户端的连接.......");
//进行客户端的监听
Socket s = ss.accept();
System.out.println("客户端已经连接!");
//创建通道内的字符缓冲输入流
BufferedReader br = new BufferedReader(new InputStreamReader(
s.getInputStream()));
//使用字符换冲流的一次读取一行的方法,将上述的数据显示在控制台上
String line=null;
while((line=br.readLine())!=null){
System.out.println(line);
}
//关闭资源
s.close();
}
}
#使用TCP编程实现在客户端从当前项目下的文本文件TCP.txt中将文件读取出来,然后发送到服务器端,在服务器端将文件中的数据重新写入另一个文本文件TCPServer.txt文本文中;
客户端:
package TCPText_02;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.FileReader;
importjava.io.IOException;
importjava.io.OutputStreamWriter;
importjava.net.Socket;
/**
* 需求:使用TCP编程实现在客户端从当前项目下的文本文件中读取文件数据,
* 然后发送到服务器端,通过服务器端将该数据重新写在文本文件中
* 1.创建客户端的Socket对象,并指明IP地址和端口号
* 2.创建字符缓冲输入流,用来封装当前项目下的文本文件TCP.txt,
* 3.创建通道内的字符缓冲输出流,
* 4.使用字符缓冲流的一次读写一行的方法来将文件中的数据发送到服务器端
* 5.关闭资源
* */
public class UploadClient_01 {
public static void main(String[] args) throws IOException {
//创建客户端的Socket对象
Socket s=new Socket("10.151.4.199",8888);
//创建字符缓冲输入流对象
BufferedReader br=new BufferedReader(new FileReader("TCP.txt") );
//创建通道内的字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
s.getOutputStream()));
//使用字符缓冲流的一次读取一行的功能获取文件数据
String line=null;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//关闭资源
s.close();
br.close();
}
}
服务器端:
packageTCPText_02;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.FileWriter;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.net.ServerSocket;
importjava.net.Socket;
/**
* 1.创建服务器端的Socket对象,并指明端口号
* 2.服务器监听客户端连接
* 3.创建通道内的字符缓冲输入流,
* 4.创建字符缓冲输出流,用来封装需要输出的文本文件
* 5.使用字符缓冲流的一次读写一行的功能来想文本文件TCPServer.txt中写数据
* 6.关闭资源
* */
public class UploadServer_01 {
public static void main(String[] args) throws IOException {
//创建服务器端的Socket对象
ServerSocket ss=new ServerSocket(8888);
System.out.println("等待客户端连接.....");
//监听客户端的连接
Socket s = ss.accept();
System.out.println("客户端连接成功!");
//创建通道内的输入流对象
BufferedReader br = new BufferedReader(new InputStreamReader(
s.getInputStream()));
//创建字符缓冲输出流对象,将获取到的数据存入文本文件TCPServer.txt中
BufferedWriter bw=new BufferedWriter(new FileWriter("TCPServer.txt"));
//使用字符缓冲流的一次读取一行的功能将数据写入文本文件中
String line=null;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//关闭资源
s.close();
bw.close();
}
}
#使用TCP编程实现在客户端从一个文本文件中读取数据,发送到服务器端,并写入另一个文本文件中,同时向客户端进行反馈,
客户端:
packageTCPText_02;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.FileReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.OutputStreamWriter;
importjava.net.Socket;
import java.net.UnknownHostException;
/**
* 需求:使用TCP编程实现在客户端从一个文本文件红读取数据,
* 发送到服务器端,在服务器端将获取到的数据写入另一个文本文件中,同时向客户端反馈.
* 1.创建客户端的Socket对象,并指明IP地址和端口号,
* 2.创建字符缓冲输入流用来封装文本文件
* 3.创建通道内的字符缓冲输出流,
* 4.使用字符缓冲流的一次读写一行的方法获取数据,并向服务器端发送数据,读完之后后调用
* public void shutdownOutput()该方法,禁止套接字的输出流,表示客户端这边已经读完数据.
* 5.创建通道内的字符缓冲输入流,用来表示服务器端的反馈
* 6.关闭资源
* */
public class UploadClient_02 {
public static void main(String[] args) throws IOException {
//创建客户端的SOcket对象
Socket s=new Socket("10.151.4.199",9999);
//创建字符缓冲输入流,用来封装文本文件
BufferedReader br=new BufferedReader(new FileReader("TCP.txt"));
//创建通道内的字符输出流,向服务器端发送数据
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
s.getOutputStream()));
//使用字符缓冲流的特有功能发送数据
String line=null;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//客户端已经读完数据
s.shutdownOutput();//该方法会抛出异常throws IOException禁用此套接字的输出流
//创建通道内的字符缓冲输入流,用来接收服务器端反馈
BufferedReader Serverbr = new BufferedReader(new InputStreamReader(
s.getInputStream()));
String string = Serverbr.readLine();
System.out.println("服务器端的反馈为:" + string);
//关闭资源
s.close();
br.close();
}
}
服务器端:
packageTCPText_02;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.FileWriter;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.OutputStreamWriter;
importjava.net.ServerSocket;
importjava.net.Socket;
/**
* 1.创建服务器端的Socket对象
* 2.进行服务器监听客户端的连接
* 3.创建通道内的字符缓冲输入流,用来接收数据,
* 4.创建字符缓冲输出流,用来封装目的地,
* 5.使用字符缓冲流的特有功能进行读写数据
* 6.创建通道内的字符缓冲输出流,用来向客户端发送反馈
* 7.关闭资源
* */
public class UploadServer_02 {
public static void main(String[] args) throws IOException {
//创建Socket对象
ServerSocket ss=new ServerSocket(9999);
//监听客户端的连接
Socket s = ss.accept();
//创建通道内的字符缓冲输入流,用来接收通道内的数据
BufferedReader br = new BufferedReader(new InputStreamReader(
s.getInputStream()));
//创建字符缓冲输出流,用来封装目的地
BufferedWriter bw=new BufferedWriter(new FileWriter("ServerTCP.txt"));
//使用字符缓冲流的特有功能进行读写操作
String line=null;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//创建通道内的字符缓冲输出流,用来想客户端进行反馈
BufferedWriter Clientbw = new BufferedWriter(new OutputStreamWriter(
s.getOutputStream()));
//想客户端进行反馈
Clientbw.write("服务器端已经读到数据呢!");
Clientbw.newLine();
Clientbw.flush();
//关闭资源
bw.close();
s.close();
}
}
#使用TCP编程实现将图片从客户端发送到服务器端,并进行反馈;
客户端:
packageTCPText_02;
importjava.io.BufferedInputStream;
importjava.io.BufferedOutputStream;
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.net.Socket;
import java.net.UnknownHostException;
/**
* 需求:使用TCP编程实现从客户端向服务器端发送图片,并反馈给客户端
* 1.创建客户端的Socket对象,并指明IP地址和端口号
* 2.创建字节缓冲输入流,来获取给文件
* 3.创建通道内的字节缓冲输出流,用来向服务器端发送文件
* 4.调用public void shutdownOutput()该方法,用来向服务器端反馈,客户端已经读完数据
* 5.创建通道内的字节缓冲输入流,用来接收服务器端的反馈
* 6.关闭资源
* */
public class UploadClient_03 {
public static void main(String[] args) throws IOException {
//创建Scoket对象,并指明IP地址和端口号
Socket s=new Socket("10.151.4.199",10000);
//创建字节缓冲输入流,封装源文件
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
"VanGogh_01"));
//创建通道内的字节缓冲输出流,用来向服务器端发送数据
BufferedOutputStream bos=new BufferedOutputStream(s.getOutputStream());
//读取数据
byte[] bys=new byte[1024];
int len=-1;
while((len=bis.read(bys))!=-1){
bos.write(bys);
bos.flush();
}
//向服务器端反馈,客户端已经读完数据
s.shutdownOutput();
//创建通道内的字节输入流,用来接收服务器端的反馈
InputStream is =s.getInputStream();
byte[] bys2=new byte[1024];
int len1=bys2.length;
String Str = new String(bys2, 0, len1);
System.out.println(" 服务器端的反馈为:" + Str);
//关闭资源
s.close();
bis.close();
//关闭资源
bos.close();
s.close();
}
}
服务器端:
packageTCPText_02;
importjava.io.BufferedInputStream;
importjava.io.BufferedOutputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.OutputStream;
importjava.net.ServerSocket;
importjava.net.Socket;
/**
* 1.创建Socket对象
* 2.进行服务器端监听客户端的连接
* 3.创建通道内的字节缓冲输入流,用来获取客户端的文件
* 4.创建字节缓冲输出流用来封装目的地
* 5.进行读写操作,向目的地中写数据
* 6.创建通道内的字节输出流,向客户端进行反馈
* 7.关闭资源
* */
public class UploadServer_03 {
public static void main(String[] args) throws IOException {
//创建Socket对象
ServerSocket ss=new ServerSocket(10000);
System.out.println("等待客户端的连接............");
//监听客户端连接
Socket s = ss.accept();
System.out.println("客户端已经成功连接!");
//创建通道内的字节缓冲输入流,
BufferedInputStream bis=new BufferedInputStream(s.getInputStream());
//创建字节缓冲输出流,用来封装目的地
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("VanGogh.jpg"));
//进行读写数据
byte[] bys=new byte[1024];
int len=0;
while((len=bis.read(bys))!=-1){
bos.write(bys);
bos.flush();
}
//创建通道内的字节输出流,向客户端进行反馈
OutputStream os=s.getOutputStream();
os.write("服务器端已经成功接收资源".getBytes());
}
}
三:反射机制:
1反射:就是通过获取到该类的字节码文件(class对象),通过该class对象获取到该类的一些属性(成员变量),成员方法,构造方法.
2.如何获取字节码文件,方法有几种?
(1)通过Object类中的getClass()方法,表示正在运行的那个类,
(2)数据类型的Class属性;例如:Person.class;
(3)调用class类的forname(StringclassName)方法,该类中的参数为String类型, 且为该类的全路径名称;public staticClass<?> forName(String className):获取字节码文件对象
#开发中,经常使用第三种方法.
#使用三种方法来获取一个类的Class字节码文件:
packageReflectText_01;
/**
* 需求:使用三种方法获取一个类的Class字节码文件
* 1.使用Object类的getClass()方法,
* 2.使用数据类型的class属性
* 3.调用class类的forName()方法,该方法返回class字节码文件
* */
public class DemoText_01 {
public static void main(String[] args) throws ClassNotFoundException {
System.out.println("使用Object类的getClass()获取该类的字节码文件--------------");
//需要通过创建具体对象,通过兑现调用该类的方法
Person p1=new Person();
Class c1 = p1.getClass();
Person p2=new Person();
Class c2 = p2.getClass();
//将上述两次获取到的字节码文件进行对比,看是否相等
System.out.println(c1==c2);
System.out.println("使用数据类型的Class属性来获取该类的class属性---------------");
Class c3=Person.class;
Class c4=Person.class;
System.out.println(c3==c4);
System.out.println(c3==c1);
System.out.println("使用Class类的froName()方法来获取该类的字节码文件------------");
Class c5=Class.forName("ReflectText_01.DemoText_01");
Class c6=Class.forName("ReflectText_01.DemoText_01");
System.out.println(c1==c5);
System.out.println(c3==c5);
System.out.println(c5==c6);
//因为一个类只有一个Class文件,所以获取到的Class字节码文件为同一个,
}
}
class Person{
private String name;//定义实例字段:成员变量位置的属性
int age;
private static int number;
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person() {
super();
// TODO自动生成的构造函数存根
}
public void speak(){
System.out.println("Teacher is looking after baby!");
}
public String show(String name){
return "Teacher" + name;
}
}
#使用反射机制获取该类中的成员方法,并且使用该方法
packageReflectText_01;
importjava.lang.reflect.Constructor;
importjava.lang.reflect.InvocationTargetException;
/**
* 需求:使用反射机制中的成员方法来获取该类中的构造方法,并使用
* 1.调用Class类的forName()方法来获取该类的字节码文件
* 2.调用public Constructor<?>[]getConstructors(),返回的是一个公共构造方法所在数组
* 3.调用public Constructor<?>[]getDeclaredConstructors():获取的是当前字节码文件对象中所有的构造方法
* 4.调用public Constructor<T> getConstructor(Class<?>...parameterTypes)返回一个 Constructor 对象，
* 它反映此 Class 对象所表示的类的指定公共构造方法,参数表示:参数数据类型的字节码文件对象,
* 获取指定构造方法里面的参数需要写上数据类型的字节码文件对象
* 5.通过获取构造器对象,然后使用该对象调用newInstance()
* */
public class DemoText_02 {
public static void main(String[] args) throws ClassNotFoundException,NoSuchMethodException, SecurityException, InstantiationException,IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//通过反射机制获取到该类的字节码文件对象
Class<?> c=Class.forName("ReflectText_01.Persons");
//获取该类的所有公共的构造方法
System.out.println("---------获取到该类的所有公共的构造方法---------");
Constructor<?>[] con1 =c.getConstructors();
System.out.println(con1);
System.out.println("---------获取到该类的所有的构造方法---------");
Constructor<?>[] con2 =c.getDeclaredConstructors();
System.out.println(con2);
System.out.println("---------获取到该类中指定的构造方法-------");
Constructor<?>con3=c.getConstructor(String.class,int.class);
System.out.println("指定的构造方法为:" + con3);
System.out.println("---------伪代码---------");
//获取构造器对象
Constructor<?> con4 =c.getConstructor(String.class,int.class);
Object obj= con4.newInstance("王抢",50);//通过伪代码的形式给变量赋值,并且调用该类的成员方法
System.out.println("该学生的信息为:" + obj);
}
}
#使用反射机制实现通过伪代码给具体类的成员变量赋值,并将其值打印在控制台上;
packageReflectText_01;
importjava.lang.reflect.Constructor;
importjava.lang.reflect.InvocationTargetException;
/**
* 需求:使用反射机制学生类成员变量赋值
* 1.调用Class类的forName()方法,获取该类的字节码文件对象
* 2.使用该字节码文件对象调用getConstructor()方法,并指明参数类型,
* 3.然后用上述得到的Constructor类型的对象调用newInstance()方法,
* 通过构造方法给成员变量赋值
* 4.最后将成员变量的值打印在控制台上
* */
public class DemoText_03 {
public static void main(String[] args) throws ClassNotFoundException,NoSuchMethodException, SecurityException, InstantiationException,IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//调用Class类的forName()方法
Class<?> c=Class.forName("ReflectText_01.Student");
//获取构造器对象
Constructor<?>con1=c.getConstructor(int.class,String.class);//该方法是获取指定的一个公共的构造方法.
//使用上述的Constructor对象调用newInstance() 方法,并通过构造参数给成员变量赋值
Object obj=con1.newInstance(23,"小芳");
System.out.println("学生的信息如下:" + obj);
}
}
class Student{
private int age;
public String name;
public Student() {
super();
}
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
@Override
public String toString() {
return "Student [age=" + age + ",name=" + name + "]";
}
}
#使用反射机制实现获取成员变量,并且给其赋值使用
packageReflectText_02;
import java.io.IOException;
importjava.lang.reflect.Field;
/**
* 需求:使用反射机制获取到一个类的成员变量,并使用它
* 1.定义一个Teacher类,该类中定义一个公共成员变量,一个私有成员变量,
* 2.在测试类中,通过反射机制获取到该类的字节码文件对象
* 3.通过该对象调用public Field[] getFields():所有的公共的可访问的字段,
* 返回的是Field对象数组;该类中的参数为被访问的成员变量的名字
* 4.在使用上述的对象调用public void set(Object obj, Objectvalue)
* 给obj实例对象里面的成员变量设置一个实际参数---->value
* 5.通过字节码文件的对象调用public Field[]getDeclaredFields():
* 获取当前字节码文件对象中所有的公共的或者私有的字段
* 6.使用上述对象调用public void set(Object obj, Objectvalue)
* 给obj实例对象里面的成员变量设置一个实际参数---->value
* 7.最后打印输出上述两个成员变量的结果
* */
public class Reflect_01 {
private static Object obj;
private static Object obj1;
public static void main(String[] args) throws ClassNotFoundException,NoSuchFieldException, SecurityException, IllegalArgumentException,IllegalAccessException,NullPointerException {
//通过Class类的forName()方法,获取到该字节码文件的对象
Class c=Class.forName("ReflectText_02.Teacher");
System.out.println("-------以下是获取指定的公共的成员变量,赋值并使用它--------");
//使用字节码文件对象调用getFields()来获取公共的成员变量
Field f1 = c.getField("age");
f1.setAccessible(true);
//给变量赋值
f1.set(obj, 33);
System.out.println("该老师的年龄为:" + obj);
System.out.println("-------以下是获取指定的成员变量,并赋值使用它--------");
Field f2 = c.getDeclaredField("name");
f2.setAccessible(true);
//使用上述对象给变量赋值
f2.set(obj1, "欧阳");
System.out.println("该老师的姓名为:" + obj1);
}
}
class Teacher{
public int age;
private String name;
public Teacher(int age, String name) {
super();
this.age = age;
this.name = name;
}
public Teacher() {
super();
// TODO自动生成的构造函数存根
}
@Override
public String toString() {
return "Teacher [age=" + age + ",name=" + name + "]";
}
}
#使用反射机制获取一个类的成员方法,并使用它
packageReflectText_02;
importjava.lang.reflect.InvocationTargetException;
importjava.lang.reflect.Method;
/**
* 需求:使用反射机制来获取类中的成员方法
* 1.创建一个具体的Animal类,在该类中定义公共的成员方法和私有的成员方法
* 2.通过Class类的forName()方法获取到该类的字节码文件对象
* 3.通过字节码文件对象调用getMathod(Stringname,class<?>...parametertypes)获取该类指定的公共的成员方法
* 4.再使用上述的Method对象调用Public Object invoke(Object obj,obj...args),获取到指定的方法,并给其参数赋值
* */
public class Reflect_02 {
private static final Object obj = null;
public static void main(String[] args) throws ClassNotFoundException,NoSuchMethodException, SecurityException, IllegalAccessException,IllegalArgumentException, InvocationTargetException {
//通过Class类的forName()获取到该类的字节码文件对象
Class c=Class.forName("ReflectText_02.Animal");
//获取该类中指定的公共成员方法
Method m1=c.getMethod("speak", String.class);
//使用上述对象调用invoke()方法,获取并使用成员方法
m1.setAccessible(true);
m1.invoke(obj, "嘿嘿嘿....");
System.out.println(obj);
}
}
class Animal{
private int age;
public String name;
public void speak(String word){
System.out.println("animal has their languages!" + word);
}
String talk(){
return "this is folg!";
}
private int live(int a){
return a;
}
@Override
public String toString() {
return "Animal [age=" + age + ",name=" + name + "]";
}
}
#集合中使用反射机制添加元素
packageTCPText_03;
importjava.lang.reflect.Method;
importjava.util.ArrayList;
/**
* 需求:使用反射机制相机和中添加数据(有一个ArrayList(Integer)需要向集合中添加String类型的数据
* 1.创建一个ArrayList集合
* 2.使用该集合对象调用getClass()获取到给集合类的字节码文件
* 3.使用上述的字节码文件对象调用getMethod()获取到公共的指定的add()方法
* 4.再使用上述的Method对象调用Invoke()方法,并向集合中添加数据
* */
public class ReflectArraylist_01 {
private static Object o;
public static void main(String[] args) throws NoSuchMethodException,SecurityException,IllegalArgumentException,InvocationTargetException {
//创建ArrayList集合,并指明泛型
ArrayList<Integer> al=new ArrayList<Integer>();//该集合对象就是构造器对象
//使用上述的构造器对象调用getClass()来获取到该类的字节码文件对象
Class<? extends ArrayList> c = al.getClass();
//使用上述字节码文件对象调用getMethod()方法获取到add()方法
Method m=c.getMethod("add", Object.class);
//再使用上述的Method对象调用invoke()方法向集合中添加元素
m.invoke(o, "this ");
m.invoke(o, "is ");
m.invoke(o, "my ");
m.invoke(o, "life!");
System.out.println("该集合中的元素为:" + o);
}
}
#反射机制使用在配置文件中;
测试类:
packageTCPText_04;
import java.io.FileNotFoundException;
importjava.io.FileReader;
importjava.io.IOException;
importjava.lang.reflect.Constructor;
importjava.lang.reflect.InvocationTargetException;
import java.util.Properties;
/**
* 需求:反射机制使用在配置文件中
* 1.分别创建学生类,老师类,在类中定义一个公共的成员方法
* 2.创建一个文本文件,将其类的全路径名称赋给变量ClassName,公共的成员方法名称赋值给MethodName
* 3.在创建FileReader对象,用来封装数据源文件,并且使用使用属性集合类的Load()方法将改文本文件加载到测试类中
* 4.
* */
public class ReflectProp_01 {
public static void main(String[] args) throws IOException,
ClassNotFoundException,NoSuchMethodException, SecurityException, InstantiationException,IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//创建属性集合类的对象
Properties prop=new Properties();
//创建FileReader类对象,用来封装数据源
FileReader fr=new FileReader("ReflectText");
//将文本文件中的内容加载出来
prop.load(fr);
//关闭资源
fr.close();
//使用属性集合类的特有方法,通过键找到值
String ClassName1 = prop.getProperty("ClassName1");
String MethodName1 = prop.getProperty("MethodName1");
//获取到该类的字节码文件对象
Class c=Class.forName(ClassName1);
//获取构造器对象
Constructor con=c.getConstructor();
//通过构造器创建该类的实例
Object obj=con.newInstance();
System.out.println(obj);
}
}
老师类:
packageTCPText_04;
public class Teacher {
public void speak(){
System.out.println("老师说好好学习,天天向上!");
}
}
学生类:
packageTCPText_04;
public class Student {
public void speak(){
System.out.println("学生说,我不爱学习!!!");
}
@Override
public String toString() {
return "Student [getClass()=" + getClass() + ", hashCode()="
+ hashCode() + ", toString()=" + super.toString() + "]";
}
}
文本类:
ClassName1=TCPText_04.Student
MethodName1=speak
ClassName2=TCPText_04.Teacher
MethodName2=speak