####java类里的public,protected,private
1. public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用
2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。
3、protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，
protected就变成private。
与c++的public,private,protected不同，java是以是否在同一个package为基准
作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
####java反射反射是什么
Reflection（反射）就是Java程序在运行时可以动态得到程序内部所有类的内部信息，并能动态调用任意对象的内部属性和方法。
为什么需要反射
我们为什么要用反射，这主要是反射的动态性决定的，由于反射可以实现动态创建对象，这就很大程度发挥了java的灵活性，降低了程序调用的耦合性，使系统可以更加的灵活，可以更好的应对变化。
反射应用
运行反射我们可以做到：
在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的成员变量和方法
生成动态代理
跟反射相关的常用类主要有：
java.lang.Class:代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造方法
Class类
Class类是反射机制的源头，实际上所谓的反射从程序的运行结果来看就是，通过对象反射获取类的名称。
反射其实是类正常方式使用的反过程就像物理学中的反射一样：
通过反射我们可以得到的信息：某个类的属性、方法、构造器、类实现了哪些接口、父类是什么。对于每个类而言，JRE都为其保留了一个不变的Class类型的对象，一个Class对象包含了特定某个类的有关信息。
Class本身也是一个类，每个类在JVM中只有有一个Class实例，每个Class对象对应的是一个加载到JVM中的一个.class文件，每个类的实例都会记得自己是由哪个Class实例所生成的。
通过反射得到Class类对象，四种方式
我们现在有一个建立好的类Person，类路径是package com.tgb.reflect.common；
1.已知具体Person类，通过Person类的class属性获取，该方法最为安全可靠，程序性能最高。
1. @Test
2. public void
3. Classclass1 = Person.class;
4. System.out.println(class1);
5. }
2.已知Person类的实例，调用该实例的getClass()方法获取Class对象
1. @Test
2. public void
3. Personp = new
4. Classclass1 =p.getClass();
5. System.out.println(class1);
6. }
3.已知Person类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取。
1. @Test
2. public void test3()throws
3. StringclassName = "com.tgb.reflect.common.Person";
4. Classclass1 = Class.forName(className);
5. System.out.println(class1);
6. }
4.通过类加载器来获取Class对象。
1. @Test
2. public void test4()throws
3. StringclassName= "com.tgb.reflect.common.Person";
4. ClassLoaderclassLoader =this.getClass().getClassLoader();
5. Classclass1=classLoader.loadClass(className);
6. System.out.println(class1);
7. }
以上四种方式得到Class对象的代码经运行得到的结果是一样的，运行结果是"classcom.tgb.reflect.common.Person";
类加载器
当我们程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。
ClassLoader（类加载器）是用来把类（.class）装在进入内存的，JVM在运行时会产生3个类加载器组成的初始化加载器层次结构 ，如下图所示：
我们通过代码来看下：
1. @Test
2. public void test1()throws
3.
4. //1.获取一个系统类加载器
5. ClassLoaderloader1 =ClassLoader.getSystemClassLoader();
6. System.out.println("系统类加载器为:"+loader1);
7.
8. //2.获取系统类加载器的父类加载器，即扩展类加载器
9. ClassLoaderloader2 = loader1.getParent();
10. System.out.println("扩展类加载器:"+loader2);
11.
12. //3.获取扩展类加载器的父类加载器，即引导类加载器
13. ClassLoaderloader3 = loader2.getParent();
14. System.out.println("引导类加载器:"+loader3);
15.
16. //4.测试当前类由哪个类加载器进行加载
17. Classclass1 = Person.class;
18. ClassLoaderloader4= class1.getClassLoader();
19. System.out.println("当前类的类加载器:"+loader4);
20.
21. //5.测试JDK提供的String类由哪个类加载器加载
22. StringclassName= "java.lang.String";
23. Classclass2 = Class.forName(className);
24. ClassLoaderloader5= class2.getClassLoader();
25. System.out.println("JDK提供的String类加载器:"+loader5);
26.
27. }运行结果为:
系统类加载器为:sun.misc.Launcher$AppClassLoader@60e53b93
扩展类加载器:sun.misc.Launcher$ExtClassLoader@5acf9800
引导类加载器:null
当前类的类加载器:sun.misc.Launcher$AppClassLoader@60e53b93
JDK提供的String类加载器:null
由代码运行结果我们可以看到，我们自己定义的类是由系统类加载器加载的、系统类加载器上一级是扩展类加载器、扩展类加载器上一级系统不允许我们拿到，但是扩张类加载器上一级确实是引导类加载器，这类加载器主要是用来加载jvm自带的类库的。
关于类加载器有时候我们可以用来读取系统中的配置文件，下面我们就个简单的小例子，我们将一个Test.properties文件放到我们的类目录中，我们用类加载器来读取其中的内容。
我们配置文件的内容很简单：
user=root
password=123456
代码如下：
1. @Test
2. public void test2()throws
3. //获得类加载器
4. ClassLoaderclassLoader = this.getClass().getClassLoader();
5.
6. //运用类加载器读取property文件到输入流中
7. StringfilePath = "com\\tgb\\reflect\\test1\\Test.properties";
8. InputStreaminputStream = ClassLoader.getSystemResourceAsStream(filePath);
9.
10. //获取文件内容
11. Propertiesproperties =new
12. properties.load(inputStream);
13. Stringuser=properties.getProperty("user");
14. System.out.println("user:"+user);
15. Stringpassword = properties.getProperty("password");
16. System.out.println("password:"+password);
17.
18. }
19.
运行结果是：
user:root
password:123456
后记
这篇文章介绍了反射的基本知识，还有反射的源头Class类，并讲述了得到Class类对象的四种方式，同时还介绍了类加载器的一些知识，关于反射这篇文章就先介绍这么多，下篇文章我们继续。
#############################################################################
#java super关键字
public class java_test {
java_test(){
System.out.println("ccdd");
}
public static void main(String args[]){
java_test1 a = new java_test1();
a.a(1);
}
void printfx(){
System.out.println("aabb");
}
}
class java_test1 extends java_test{
java_test1(){
super(); //用super调用基类的构造函数，必须是在子类的构造函数里边调用
}
void a(int a){
System.out.println("java_test1");
super.printfx(); //调用父类的成员函数，就不必像调用基类的构造函数一样在构造函数里边调用
}
}
