标签：java socket 基础 name personClazz String import 加载

socket.shutdownoutput//socket的半关闭;

在输出流已经输出结束 帮助客户端跳出读取循环的方式;

--

反射

 类加载的过程:

之后是显示赋值，构造器赋值等；（静态成员变量和静态代码块看书写顺序）

双亲委派模型： 类加载是一个懒加载，会先加载父类极其父类的类，最后加载自身；

 新的jar包要进行add lib操作；

 final static修饰的值，在编译的时赋值，在“准备”阶段的时候已赋值；准备阶段静态成员变量进行初始化

1.类加载器

1Bootstrap ClassLoader根类加载器

核心类加载（lang包等）

2 Extension ClassLoader  扩展类加载器

3 System（APP） Classloader 系统加载器

负责加载自己定义的java类 

类加载器的双亲委派机制

 类加载时机；

1.创建类的实例（new 对象）

2.访问类的静态变量（首次）

3.访问类的静态方法（首次）

4.反射（创建接口或对象）

5.加载某个子类的对象会触发父类的类加载

6.直接使用java.exe命令运行某个主类，也就是执行main方法；

java代码的三个阶段

 1.阶段其实就是代码变成class文件；

2.阶段就是类加载器进行类加载的阶段；

3.就是运行代码了；

反射（重要）

        获取运行时类信息的技术

Class类的特点：

 获取字节码文件的三个方式：

1.Class.forName（"全限定类名"）

2.类名点Class；

3.对象名点getClass（）；

推荐使用第一种，第三种麻烦，第二种不能触发完整内加载

------------

 

Properties properties = new Properties();
properties.load(new InputStreamReader(
        new FileInputStream("config.properties"),"GBK"));
String ip = properties.getProperty("ip");
String port = properties.getProperty("port");

 #表示注释

 

 

 

 getModifiers的调用对象是反射出的成员属性，或者方法

 

 

package _018dayClass;

import sun.nio.cs.ext.GBK;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Hashtable;
import java.util.List;
import java.util.Properties;

/**
 * @author looper
 * @
 **/
public class _01Demo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        Class<?> personClazz = Class.forName("_018dayClass.Person");
        //获取所有public的构造方法
        Constructor<?>[] constructors = personClazz.getConstructors();
        //获取所有的构造方法
        Constructor<?>[] declaredConstructors = personClazz.getDeclaredConstructors();
        //获取指定的public的构造方法,不带s
        Constructor<?> constructors1 = personClazz.getConstructor(String.class);
        //通过构造方法实例化对象
        Object o = personClazz.getConstructor(String.class, int.class, String.class).newInstance("张三", 20, "男");
        Constructor<?> deconstrutor = personClazz.getDeclaredConstructor(String.class, int.class);
        deconstrutor.setAccessible(true);
        Object o1 = deconstrutor.newInstance("破解", 15);
        //获取成员变量
        Field[] fields = personClazz.getFields();
        Field[] declaredFields = personClazz.getDeclaredFields();
        Field nameFiled = personClazz.getField("name");
        Field ageFiled = personClazz.getDeclaredField("age");
        ageFiled.setAccessible(true);
        Constructor<?> declaredConstructor = personClazz.getDeclaredConstructor();
        Object o2 = declaredConstructor.newInstance();
        Person o21 = (Person) o2;//属性.set（对象，赋值）
        nameFiled.set(o21, "王五");//某个对象上的值
        nameFiled.get(o21);//获取某个对象上的name
        //获取成员方法
        Method[] methods = personClazz.getMethods();
        Method[] declaredMethods = personClazz.getDeclaredMethods();
        Method eat = personClazz.getMethod("eat");
        eat.setAccessible(true);
        Object invoke = eat.invoke(o21);
        Method eat1 = personClazz.getDeclaredMethod("eat", String.class);
        eat1.setAccessible(true);
        //方法的形参，从这里传递
        eat1.invoke(o21,"米饭");
        //有默认无参构造的情况下，直接字节码对象来生成对象
        Object o3 = personClazz.newInstance();
//
        System.out.println(personClazz.getSimpleName());
        System.out.println(personClazz.getSuperclass());
        System.out.println(personClazz.getName());
        System.out.println(personClazz.getInterfaces());
//权限修饰符
        Field[] declaredFields1 = personClazz.getDeclaredFields();
        int modifiers = declaredFields1[0].getModifiers();
        Class<?> type = declaredFields1[0].getType();
        System.out.println(type.getSimpleName());
        Class<?> returnType = eat1.getReturnType();
        System.out.println(returnType);


    }
}

class Person {
    public String name;
    private int age;
    private String gender;

    private Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }

    public Person(String gender) {
        this.gender = gender;
    }

    public Person(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public void eat() {
        System.out.println("吃了");
    }

    private void eat(String food) {
        System.out.println("吃了" + food);
    }
    public static void eat1() {
        System.out.println("吃了" );
    }
}

标签：java,socket,基础,name,personClazz,String,import,加载
来源： https://blog.csdn.net/looperjustice/article/details/120342615

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。