黑马程序员—高新知识点复习

最新推荐文章于 2026-05-18 12:35:54 发布

原创最新推荐文章于 2026-05-18 12:35:54 发布 · 613 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

本文深入探讨了Java反射机制的基础应用，包括获取成员变量、成员方法和构造方法，并通过实例展示了如何使用反射来实现数组或对象的遍历。此外，文章还详细介绍了Java代理的概念与实现方式，通过具体代码演示了如何利用代理来增强类的功能。

高新知识点复习

======================================================================

反射：

反射基础：

package reflect;

import java.lang.reflect.*;;

public class FieldDemo {

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

//获取成员变量

Person p = new Person("李明",23);

Class clazz = Class.forName("reflect.Person");

Field fiels = clazz.getDeclaredField("name");//如果非public必须用getDeclaredField

fiels.setAccessible(true);//如果为private，必须用setAccessible设置可用性

String name = (String)fiels.get(p);

System.out.println(name);

//获取成员方法

Method method = clazz.getDeclaredMethod("show");//如果非public必须用getDeclaredMethod

method.setAccessible(true);//如果为private，必须用setAccessible设置可用性

method.invoke(p);

//获取构造方法

Constructor con = clazz.getDeclaredConstructor(String.class,int.class);

Person p2 = (Person)con.newInstance("张三",29);

System.out.println(p2.age);//p2.name报错，因为为私有

}

//不管是成员变量、成员方法、构造方法，如果非public，获取时都要用Declared（让其可见）,如果为private

//要用setAccessible设置其可用性

class Person{

private String name;

int age;

Person(String name, int age) {

super();

this.name = name;

this.age = age;

}

private void show(){

System.out.println(this.name + ":" + this.age);

}

======================================================================

定义一个功能，输出数组或者是对象或者单个变量，如果是一个就打印一个，如果是数组就打印数组中的所有元素

package reflect;

import java.lang.reflect.Array;

public class PrintAll {

public static void main(String[] args) {

int i = 9;

printAllme(i);

printAllme("dfadf");

printAllme(new String[]{"123","tyui","789654"});

}

//定义一个功能，输出数组或者是对象或者单个变量，如果是一个就打印一个，如果是数组就打印数组中的所有元素

//通过反射的方法判断传递进来的参数是数组还是非数组

public static void printAllme(Object o){

if(o.getClass().isArray()){

int olength = Array.getLength(o);

for (int i = 0; i < olength; i++) {

System.out.println(Array.get(o,i));

}

}else{

System.out.println(o);

}

======================================================================

替换类中String类型字段的字符

package reflect;

import java.lang.reflect.*;;

public class ReplaceDemo {

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

//替换一个类中所有String类型变量的指定字符

Student s1 = new Student("zhangsan","shanghai");

System.out.println(s1.name + ":" + s1.addr);

Class clazz = Class.forName("reflect.Student");

Field[] fields = clazz.getFields();//首先获取一个类中所有的成员变量

//遍历的得到的成员变量的同时，判断是否是字符串类型

for(Field f : fields){

if(f.getType() == String.class){

String oldValue = (String)f.get(s1);

String newValue = oldValue.replace('a','b');

f.set(s1,newValue);

}

System.out.println(s1.name + ":" + s1.addr);

}

class Student{

public String name,addr;

public Student(String name, String addr) {

super();

this.name = name;

this.addr = addr;

}

======================================================================

代理：

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.ArrayList;

import java.util.Collection;

import java.util.LinkedList;

public class ProxyDemo1 {

public static void main(String[] args) {

Collection colle = new ArrayList();

//调用proxy方法只需告诉方法生成那个类的代理类，和实现了附加功能类的对象

Collection proxy = (Collection)getProxy(colle,new MyAdvice());

//调用集合中的方法，根据输出结果可知，的确调用了InvocationHandandler的invoke方法

colle.add("abcde");

System.out.println(proxy.size());

System.out.println(colle.size());

}

//把生成动态代理类的代码封装在方法中，这样可以动态传递参数，告诉Proxy的方法到底生成实现了哪一个接口的类的代理类,还有附加功能所属的接口。

public static Object getProxy(final Object o,final Advice advice){//因为内部类要访问，所以为final

//调用Proxy的newProxyInstance方法，生成代理类，

Object Proxy1 = (Object)Proxy.newProxyInstance(Object.class.getClassLoader(),o.getClass().getInterfaces(), new InvocationHandler(){

@Override

public Object invoke(Object object, Method method, Object[] args)

throws Throwable {

//代理类增加的功能

advice.before();

Object oo = method.invoke(o, args);

advice.after();

return oo;

}

});

return Proxy1;

}

//定义一个类，实现附加功能接口，

class MyAdvice implements Advice{

public void before() {

System.out.println("方法调用前");

}

public void after() {

System.out.println("方法调用后");

}

//定义一个附加功能的接口，作为规则，只要是实现了此接口的类，都可以作为参数传递给getProxy

interface Advice{

abstract void before();

abstract void after();

}

======================================================================

UDP聊天程序

import java.net.*;

import java.io.*;

//一个程序能同时发送和接收信息，需要用到多线程。把接收和发送的代码交给两个线程去执行

public class Udpp {

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

new Thread(new Send()).start();

new Thread(new Rec()).start();

}

//把发送代码交给一个线程

class Send implements Runnable{

public void run(){

BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));

DatagramSocket ds = null;

try {

ds = new DatagramSocket();

} catch (SocketException e) {

e.printStackTrace();

}

while(true){

try{

byte[] b = bfr.readLine().getBytes();

DatagramPacket dp = new DatagramPacket(b, b.length,InetAddress.getByName("192.168.33.80"),9600);

ds.send(dp);

}catch(Exception e){

e.printStackTrace();

}

//把接收代码交给一个线程

class Rec implements Runnable{

public void run(){

DatagramSocket ds = null;

try {

ds = new DatagramSocket(9700);

} catch (SocketException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

while(true){

try{

byte[] b2 = new byte[1024];

DatagramPacket dp2 = new DatagramPacket(b2,b2.length);

ds.receive(dp2);

String s = new String(dp2.getData(),0,dp2.getLength());

System.out.println(s);

}catch(Exception e){

e.printStackTrace();

}