java的类基础

####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属性获取，该方法最为安全可靠，程序性能最高。

[java] view plaincopy

1. @Test  

2. public void test1(){  

3. Classclass1 = Person.class;  

4. System.out.println(class1);  

5. }  

 

 

    2.已知Person类的实例，调用该实例的getClass()方法获取Class对象

[java] view plaincopy

1. @Test  

2. public void test2() {  

3. Personp = new Person();  

4. Classclass1 =p.getClass();  

5. System.out.println(class1);  

6. }  

 

 

    3.已知Person类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取。

[java] view plaincopy

1. @Test  

2. public void test3()throws ClassNotFoundException{  

3. StringclassName = "com.tgb.reflect.common.Person";  

4. Classclass1 = Class.forName(className);  

5. System.out.println(class1);  

6. }  

    4.通过类加载器来获取Class对象。

 [java] view plaincopy

1. @Test  

2. public void test4()throws ClassNotFoundException{  

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个类加载器组成的初始化加载器层次结构 ，如下图所示：

 

 

 

    我们通过代码来看下：

 

[java] view plaincopy

1. @Test  

2. public void test1()throws ClassNotFoundException{  

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

 

    代码如下：

[java] view plaincopy

1. @Test  

2. public void test2()throws IOException{  

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 Properties();  

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(); //调用父类的成员函数，就不必像调用基类的构造函数一样在构造函数里边调用
  }
}

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！