Day28

今天也是认真学习的一天，专注时间大于5个小时，风雨无阻。努力是会有回报的，加油OVO，马上就能把基础知识都学完了，可以开始进阶了

Day28

五道问题

1. 一个IP对于着哪个类的一个对象？ 实例化这个类的方式是？两个常用的方法是？

InetAddress类

InetAddress.getbyName(String host)

InetAddress.getlocalHost():获取本地Ip

getHostName()

getHostAddress()

2. 传输层的TCP协议和UDP协议的主要区别是？

   TCP ：可靠的数据传输(三次握手)；进行大数据量的传输；效率低

    

   UDP：不可靠；以数据报形式发送，数据报限定为64k；效率高

3. 什么是URL，写一个URL。

   URL：统一资源定位符。

   URL url = new URL(“http://192.168.1.1:8080/examples/hello.txt?username=tom”)

4. 对象序列化机制的理解。

   序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去。

   反序列过程：将磁盘文件中的对象还原为内存中的java对象。

5. 对象想要实现序列化，需要满足几个条件？

• 1.实现Serializable的接口。---->标识接口，这个接口没有任何方法。

• 2.需要当前类，提供一个全局常量：serialVersionUID

• 3.要求对象的属性也必须是可序列的。还必须保证其内部属性也必须是可序列化的。(默认情况下，基本数据类型是可序列的)

 

Java反射机制

重点：

1.获取Class实例

2.创建运行时类的对象

3.调用运行时类的指定结构

 

概述：

反射被视为动态语言的关键，反射机制允许程序在执行期借助于反射API取得任何类得内部信息，并能够直接操作任意对象得内部属性和方法。

 

反射相关的API

java.lang.Class：代表一个类。

java.lang.reflect.Method:代表类的方法

java.lang.reflect.Field:代表类的成员变量

java.lang.reflect.Constructor：代表类的构造器

以下的类都可以有Class对象

1. class: 外部类，成员(成员内部类、静态内部类)，局部内部类，匿名内部类

2. interface：接口

3. [] 数组

4. enum：枚举

5. annotation：注解@interface

6. primitive type：基本数据类型

7. void：（没有返回值的类型）

今日代码

package com.sorrymaker.reflection;
​
import org.junit.Test;
​
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
​
    /**
     *
     * 疑问：1.反射机制与面向对象中的封装性是不是矛盾？如何看待两个技术？
     *        不矛盾，封装性是建议你别调用私有的，而反射是允许你调用私有的，一个是给建议，一个是功能性。
     *      2.通过直接new 对象或是反射的方式都可以调用公共的结构，开发中到底用哪个？
     *      建议使用 new 的方式，
     *      什么时候会用反射的方式：编译的时候不确定到底要new哪个对象，前端发送的对象不确定，所以后端也需要动态的应对，需要用到后端。
     *      反射的特征：动态性，
     */
​
public class Reflection {
​
    /**
     * 关于java.lang.Class类的理解
     * 1.类加载的过程
     * 程序经过java.lang.exe命令以后，会生成一个或多个字节码文件(.class结尾),接着我们使用
     * java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中，此过程
     * 就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。
     *
     * 2.换句话说，Class的实例就对应着一个运行时类，
     *
     */
​
    @Test
    //获取Class的实例方式。
    public void test3() throws ClassNotFoundException {
        //方式一：调用运行时类的属性:  .class
        Class clazz1 = Person.class;
        System.out.println(clazz1);
​
        //方式二：通过运行时类的对象: .getClass()
        Person p1 =new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);
​
        //方式三：调用Class的静态方法：forName(String classPath)
        Class clazz3 = Class.forName("com.sorrymaker.reflection.Person");
        System.out.println(clazz3);
​
        //加载到内存中的运行时类，会缓存一定的时间，在此时间内，可以通过不同的方式来获取此运行时类。
        System.out.println(clazz1 == clazz2);
        System.out.println(clazz2 == clazz3);
​
        //方式四：使用类的加载器：ClassLoder
        ClassLoader classLoader = Reflection.class.getClassLoader();
        Class clazz4 = classLoader.loadClass("com.sorrymaker.reflection.Person");
        System.out.println(clazz4);
​
        System.out.println(clazz4 == clazz1);
​
    }
    //反射之前对于Person类的操作
    @Test
    public void test1(){
        //1.创建Person类的对象
        Person p1 =new Person("tom",12);
​
        //2.通过对象，调用其内部的属性和方法
        p1.age =10;
        System.out.println(p1.toString());
​
        p1.show();
        //在Person类的外部，不可以通过Person类的对象调用其内部私有结构。
        //比如：name，showNation()以及私有的构造器。
​
    }
    //反射之后，对于person的操作
    @Test
    public void test2() throws Exception {
        //1.通过反射创建Person类的对象
        //Class：反射源头
        Class clazz = Person.class;
        Constructor cons =clazz.getConstructor(String.class,int.class);
​
        Object obj = cons.newInstance("tom", 12);
        Person p =(Person)obj ;
        System.out.println(p.toString());
​
        //2.通过反射，调用对象指定的属性
        Field age = clazz.getDeclaredField("age");
        age.set(p,10);
        System.out.println(p);
​
        //3.通过反射，调用对象指定的方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);
​
        //4.通过反射，可以调用Person类的私有结构的，比如：私有的构造器、方法、属性
        //调用私有的构造器
        Constructor cons1 = clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Person p1 = (Person)cons1.newInstance("jerry");
        System.out.println(p1);
​
        //调用私有的的属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p1,"QQ");
        System.out.println(p1);
​
        //调用私有的方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        //相等于String nation = p1.showNation("中国")
        String nation =(String) showNation.invoke(p1,"中国");
        System.out.println(nation);
    }
}

 

ClassLoaderTest

package com.sorrymaker.reflection;
​
import org.junit.Test;
​
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
​
/**
 * 了解类的加载器
 *
 */
public class ClassLoaderTest {
​
    @Test
    public void test1(){
        //获取系统类加载器
        //对于自定义类，使用系统类加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        //sun.misc.Launcher$AppClassLoader@18b4aac2
        System.out.println(classLoader);
​
        //调用系统类加载器的getParent()：获取拓展类加载器
        ClassLoader classLoader1 = classLoader.getParent();
        //上一层的加载器是扩展类加载器
        //sun.misc.Launcher$ExtClassLoader@54bedef2
        System.out.println(classLoader1);
​
        //调用拓展类加载器的getParent()：无法获取引导类加载器
        //引导类加载器主要复制加载java的核心类库，无法加载自定义类的。
        ClassLoader classLoader2 = classLoader1.getParent();
        System.out.println(classLoader2);
​
        ClassLoader classLoader3 = String.class.getClassLoader();
        System.out.println(classLoader3);
    }
​
    /**
     * Properties:用来读取配置文件。
     */
    @Test
    public void test2() throws IOException {
        Properties pros =new Properties();
        //读取配置文件的方式一：（差别是路径的读取）
        FileInputStream fis =new FileInputStream("src/com/sorrymaker/reflection/jdbc.properties");
        pros.load(fis);
​
        //读取配置文件的方式二：（差别是路径的读取）
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("com/sorrymaker/reflection/jdbc.properties");
        pros.load(is);
​
        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        System.out.println("user="+user+",password"+password);
    }
}
​