Java 中import的用法，以及类的种类

1 类Human的访问修饰符是缺省访问控制符(即default)，即类Human在包Human外是不可见的，只能被同一个包中的类访问或引用，所以你在包Human外写个程序是访问不了类Human的。2 把写的程序放到包Human里面去，再次运行，提示：找不到符号：Human 首先是否编译了类Human; 其次在编译 放入包Human的那个程序 时要导入 类Human 的路径，Human类在包Human中，所以编译时采用 javac -cp Human类路径 放入包Human的那个程序类 (注意：Human类路径中不包含包Human，就是到包Human的父文件夹), 也可以直接在包Human中用javac java编译即可 注意运行时当前路径要与包Human目录同级在此还简单的说下对包和类的导入的理解：在Java中，是使用包来组织类的，其作用是确保类的唯一性，如有可能在同一个项目中，两个不同的程序员定义了相同名字的类Human，其各自把自己定义的Human类放在自己的定义的包中就不会冲突了(也就是包名是不同的)，为了确保包名的绝对唯一性，在项目开发中，常把公司的域名逆序后做为包名，并对不同的项目采用不同的子包(如combaidu; cncomsina等就是域名逆序，cncomsinaproject1, cncomsinaproject2 就是不同的项目包命名)一个类可以使用所属包中的所有类，也可以访问其他包中的公有类(即public类), 而要访问另一个包中的公有类，有两种做法：第一种是在每个类名前加完整的包名，如javautilDate date = new Date();另外一种就是使用import语句，如import javautilDate; import语句导入了类，但真正定位包中的类是编译器的工作，其实在字节码文件(以class后缀的文件)中还是使用完整的包名来引用其他类的。把类放入包中，就是把包名放在类源码文件第一行，如package human;类的种类根据修饰符(modifiers)(不考虑内部类)对类的修饰，可以确认一个类：public class 类名{}:公共类，其可以被所有类访问，能实例化(也就是new *** 作);public abstract class 类名{}：抽象类,不可以实例化;public final class 类名{}：final类,不可继承；class 类名{}:同一包中可以被访问；从上可以看出，能修饰类的修饰符就是public,abstract,final,没有修饰符(default)，其中abstract和final不能同时使用。

一般可以使用反射来获取泛型参数的实际类型，以下是详细代码：

import javalangreflectField;

import javalangreflectParameterizedType;

import javalangreflectType;

import javautilMap;

public class GenericTest {

/使用反射来获取泛型信息/

private Map<String, Integer> score;

public static void main(String[] args) throws SecurityException, NoSuchFieldException {

//Class clazz = GenericTestclass;

Class<GenericTest> clazz = GenericTestclass;

//Systemoutprintln(clazz);

Field f = clazzgetDeclaredField("score");

//直接使用getType只对普通类型有效，无法取到泛型参数

Class<> a = fgetType();

Systemoutprintln("score的类型是："+a);

//获得Field实例f的泛型类型

Type gType = fgetGenericType();

//如果gType类型是ParameterizedType的对象

if (gType instanceof ParameterizedType) {

ParameterizedType pType = (ParameterizedType) gType;

//获取原始类型

Type rType = pTypegetRawType();

Systemoutprintln("原始类型是："+rType);

//取得泛型类型参数

Type[] tArgs = pTypegetActualTypeArguments();

Systemoutprintln("泛型类型是：");

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

Systemoutprintln("第"+i+"个泛型类型是："+tArgs[i]);

}

}else{

Systemoutprintln("获取泛型类型出错！");

}

}

}

输出结果如下：

score的类型是：interface javautilMap

原始类型是：interface javautilMap

泛型类型是：

第0个泛型类型是：class javalangString

第1个泛型类型是：class javalangInteger

Java反射机制详解

1 反射机制是什么

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

2 反射机制能做什么

反射机制主要提供了以下功能：

在运行时判断任意一个对象所属的类；

在运行时构造任意一个类的对象；

在运行时判断任意一个类所具有的成员变量和方法；

在运行时调用任意一个对象的方法；

生成动态代理。

3 反射机制的相关API

通过一个对象获得完整的包名和类名

package netxsoftlabbaike;

public class TestReflect {

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

        TestReflect testReflect = new TestReflect();

        Systemoutprintln(testReflectgetClass()getName());

        // 结果 netxsoftlabbaikeTestReflect

    }

}

实例化Class类对象

package netxsoftlabbaike;

public class TestReflect {

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

        Class<> class1 = null;

        Class<> class2 = null;

        Class<> class3 = null;

        // 一般采用这种形式

        class1 = ClassforName("netxsoftlabbaikeTestReflect");

        class2 = new TestReflect()getClass();

        class3 = TestReflectclass;

        Systemoutprintln("类名称   " + class1getName());

        Systemoutprintln("类名称   " + class2getName());

        Systemoutprintln("类名称   " + class3getName());

    }

}

获取一个对象的父类与实现的接口

package netxsoftlabbaike;

import javaioSerializable;

public class TestReflect implements Serializable {

    private static final long serialVersionUID = -2862585049955236662L;

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

        Class<> clazz = ClassforName("netxsoftlabbaikeTestReflect");

        // 取得父类

        Class<> parentClass = clazzgetSuperclass();

        Systemoutprintln("clazz的父类为：" + parentClassgetName());

        // clazz的父类为： javalangObject

        // 获取所有的接口

        Class<> intes[] = clazzgetInterfaces();

        Systemoutprintln("clazz实现的接口有：");

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

            Systemoutprintln((i + 1) + "：" + intes[i]getName());

        }

        // clazz实现的接口有：

        // 1：javaioSerializable

    }

}

获取某个类中的全部构造函数 - 详见下例

通过反射机制实例化一个类的对象

package netxsoftlabbaike;

import javalangreflectConstructor;

public class TestReflect {

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

        Class<> class1 = null;

        class1 = ClassforName("netxsoftlabbaikeUser");

        // 第一种方法，实例化默认构造方法，调用set赋值

        User user = (User) class1newInstance();

        usersetAge(20);

        usersetName("Rollen");

        Systemoutprintln(user);

        // 结果 User [age=20, name=Rollen]

        // 第二种方法 取得全部的构造函数 使用构造函数赋值

        Constructor<> cons[] = class1getConstructors();

        // 查看每个构造方法需要的参数

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

            Class<> clazzs[] = cons[i]getParameterTypes();

            Systemoutprint("cons[" + i + "] (");

            for (int j = 0; j < clazzslength; j++) {

                if (j == clazzslength - 1)

                    Systemoutprint(clazzs[j]getName());

                else

                    Systemoutprint(clazzs[j]getName() + ",");

            }

            Systemoutprintln(")");

        }

        // 结果

        // cons[0] (javalangString)

        // cons[1] (int,javalangString)

        // cons[2] ()

        user = (User) cons[0]newInstance("Rollen");

        Systemoutprintln(user);

        // 结果 User [age=0, name=Rollen]

        user = (User) cons[1]newInstance(20, "Rollen");

        Systemoutprintln(user);

        // 结果 User [age=20, name=Rollen]

    }

}

class User {

    private int age;

    private String name;

    public User() {

        super();

    }

    public User(String name) {

        super();

        thisname = name;

    }

    public User(int age, String name) {

        super();

        thisage = age;

        thisname = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        thisage = age;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        thisname = name;

    }

    @Override

    public String toString() {

        return "User [age=" + age + ", name=" + name + "]";

    }

}

获取某个类的全部属性

package netxsoftlabbaike;

import javaioSerializable;

import javalangreflectField;

import javalangreflectModifier;

public class TestReflect implements Serializable {

    private static final long serialVersionUID = -2862585049955236662L;

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

        Class<> clazz = ClassforName("netxsoftlabbaikeTestReflect");

        Systemoutprintln("===============本类属性===============");

        // 取得本类的全部属性

        Field[] field = clazzgetDeclaredFields();

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

            // 权限修饰符

            int mo = field[i]getModifiers();

            String priv = ModifiertoString(mo);

            // 属性类型

            Class<> type = field[i]getType();

            Systemoutprintln(priv + " " + typegetName() + " " + field[i]getName() + ";");

        }

         

        Systemoutprintln("==========实现的接口或者父类的属性==========");

        // 取得实现的接口或者父类的属性

        Field[] filed1 = clazzgetFields();

        for (int j = 0; j < filed1length; j++) {

            // 权限修饰符

            int mo = filed1[j]getModifiers();

            String priv = ModifiertoString(mo);

            // 属性类型

            Class<> type = filed1[j]getType();

            Systemoutprintln(priv + " " + typegetName() + " " + filed1[j]getName() + ";");

        }

    }

}

通过反射机制调用某个类的方法

package netxsoftlabbaike;

import javalangreflectMethod;

public class TestReflect {

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

        Class<> clazz = ClassforName("netxsoftlabbaikeTestReflect");

        // 调用TestReflect类中的reflect1方法

        Method method = clazzgetMethod("reflect1");

        methodinvoke(clazznewInstance());

        // Java 反射机制 - 调用某个类的方法1

        // 调用TestReflect的reflect2方法

        method = clazzgetMethod("reflect2", intclass, Stringclass);

        methodinvoke(clazznewInstance(), 20, "张三");

        // Java 反射机制 - 调用某个类的方法2

        // age -> 20 name -> 张三

    }

    public void reflect1() {

        Systemoutprintln("Java 反射机制 - 调用某个类的方法1");

    }

    public void reflect2(int age, String name) {

        Systemoutprintln("Java 反射机制 - 调用某个类的方法2");

        Systemoutprintln("age -> " + age + " name -> " + name);

    }

}

通过反射机制 *** 作某个类的属性

package netxsoftlabbaike;

import javalangreflectField;

public class TestReflect {

    private String proprety = null;

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

        Class<> clazz = ClassforName("netxsoftlabbaikeTestReflect");

        Object obj = clazznewInstance();

        // 可以直接对 private 的属性赋值

        Field field = clazzgetDeclaredField("proprety");

        fieldsetAccessible(true);

        fieldset(obj, "Java反射机制");

        Systemoutprintln(fieldget(obj));

    }

}

4 反射机制的应用实例

在泛型为Integer的ArrayList中存放一个String类型的对象。

package netxsoftlabbaike;

import javalangreflectMethod;

import javautilArrayList;

public class TestReflect {

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

        ArrayList<Integer> list = new ArrayList<Integer>();

        Method method = listgetClass()getMethod("add", Objectclass);

        methodinvoke(list, "Java反射机制实例。");

        Systemoutprintln(listget(0));

    }

}

通过反射取得并修改数组的信息

package netxsoftlabbaike;

import javalangreflectArray;

public class TestReflect {

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

        int[] temp = { 1, 2, 3, 4, 5 };

        Class<> demo = tempgetClass()getComponentType();

        Systemoutprintln("数组类型： " + demogetName());

        Systemoutprintln("数组长度  " + ArraygetLength(temp));

        Systemoutprintln("数组的第一个元素: " + Arrayget(temp, 0));

        Arrayset(temp, 0, 100);

        Systemoutprintln("修改之后数组第一个元素为： " + Arrayget(temp, 0));

    }

}

将反射机制应用于工厂模式

package netxsoftlabbaike;

interface fruit {

    public abstract void eat();

}

class Apple implements fruit {

    public void eat() {

        Systemoutprintln("Apple");

    }

}

class Orange implements fruit {

    public void eat() {

        Systemoutprintln("Orange");

    }

}

class Factory {

    public static fruit getInstance(String ClassName) {

        fruit f = null;

        try {

            f = (fruit) ClassforName(ClassName)newInstance();

        } catch (Exception e) {

            eprintStackTrace();

        }

        return f;

    }

}

/

  对于普通的工厂模式当我们在添加一个子类的时候，就需要对应的修改工厂类。 当我们添加很多的子类的时候，会很麻烦。

  Java 工厂模式可以参考

  >}我有一个微信公众号，经常会分享一些Java技术相关的干货，还有一些学习资源。

如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。

简单写了下，不知道是不是你要的。

import javalangreflectMethod;

import comsunorgapachebcelinternalutilClassLoader;

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

ClassLoader classLoader = new ClassLoader( new String[] { "D:\\Cheiron\\Test\\bin" });//类根路径

Class<> cl = classLoaderloadClass("orgapachecommonslangStringUtils");//类名

Method method = clgetMethod("split", Stringclass, Stringclass);//类的方法

Systemoutprintln(methodgetName());//打印方法名

String[] arrS = (String[]) methodinvoke(null, "a,a", ",");//调用方法

for (String string : arrS) {//打印返回值

Systemoutprintln(string);

}

}

以上就是关于Java 中import的用法，以及类的种类全部的内容，包括:Java 中import的用法，以及类的种类、如何获取java泛型的参数类型、java中的反射机制是什么有什么作用呢求解，谢谢。等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！