java子类

❶ java中怎样获取一个类的所有子类

1、面向对象思想的继承是子类继承父类，父类被其它子类继承在JAVA虚拟机的容器中并没有直接接口获取；

2、如果是在一个项目内获取父类的子类继承情况，参考这个代码：

packagefind;

importjava.io.File;
importjava.io.IOException;
importjava.net.URL;
importjava.util.ArrayList;
importjava.util.List;

importfind.test.Intf;
importfind.test.Man;

publicclassClassUtil{
publicstaticvoidmain(String[]args){
try{
System.out.println("接口实现类：");
for(Class<?>c:getAllAssignedClass(Intf.class)){
System.out.println(c.getName());
}
System.out.println("子类：");
for(Class<?>c:getAllAssignedClass(Man.class)){
System.out.println(c.getName());
}
}catch(ClassNotFoundExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}

/**
*获取同一路径下所有子类或接口实现类
*
*@paramintf
*@return
*@throwsIOException
*@throwsClassNotFoundException
*/
publicstaticList<Class<?>>getAllAssignedClass(Class<?>cls)throwsIOException,
ClassNotFoundException{
List<Class<?>>classes=newArrayList<Class<?>>();
for(Class<?>c:getClasses(cls)){
if(cls.isAssignableFrom(c)&&!cls.equals(c)){
classes.add(c);
}
}
returnclasses;
}

/**
*取得当前类路径下的所有类
*
*@paramcls
*@return
*@throwsIOException
*@throwsClassNotFoundException
*/
publicstaticList<Class<?>>getClasses(Class<?>cls)throwsIOException,
ClassNotFoundException{
Stringpk=cls.getPackage().getName();
Stringpath=pk.replace('.','/');
ClassLoaderclassloader=Thread.currentThread().getContextClassLoader();
URLurl=classloader.getResource(path);
returngetClasses(newFile(url.getFile()),pk);
}

/**
*迭代查找类
*
*@paramdir
*@parampk
*@return
*@throwsClassNotFoundException
*/
privatestaticList<Class<?>>getClasses(Filedir,Stringpk)throwsClassNotFoundException{
List<Class<?>>classes=newArrayList<Class<?>>();
if(!dir.exists()){
returnclasses;
}
for(Filef:dir.listFiles()){
if(f.isDirectory()){
classes.addAll(getClasses(f,pk+"."+f.getName()));
}
Stringname=f.getName();
if(name.endsWith(".class")){
classes.add(Class.forName(pk+"."+name.substring(0,name.length()-6)));
}
}
returnclasses;
}
}

❷ java中什么叫子类

java中子类的定义为在有继承关系的类中extends前面的类则是子类。

❸ java中什么是基类和子类

基类就是父类，Object类是所有类的父类，子类继承父类，继承并重写父类的方法和非私有成员变量。举个例子，车是父类，能走，有轮子是他的方法和属性，汽车，自行车，火车就是子类，继承了父类走的方法，又重载了轮子的个数这个属性。大概就是这样，不理解可以看看Java核心技术第一卷

❹ java定义类和子类中的方法

{
	privateStringname;
	privateintage;
	privateStringfavor;

	publicFather(Stringname,intage,Stringfavor)
	{
		super(name,age);
		this.favor=favor;
	}

	publicStringgetName()
	{
		returnname;
	}

	publicvoidsetName(Stringname)
	{
		this.name=name;
	}

	publicintgetAge()
	{
		returnage;
	}

	publicvoidsetAge(intage)
	{
		this.age=age;
	}

	publicStringgetFavor()
	{
		returnfavor;
	}

	publicvoidsetFavor(Stringfavor)
	{
		this.favor=favor;
	}

	voidSys()
	{
		System.out.println("我是父亲，"+"我的名字是"+this.getName()+"，我的年龄是"+this.getAge()+"岁，我的爱好是"
				+this.getFavor());
	}
}

classParents
{
	publicParents(Stringname,intage)
	{}
}

❺ java子类有什么用

通俗点说
JAVA是一种高级语言,现在流行于网络和手机软件游戏方面,JAVA软件现在是免费下载和使用的。很受编程爱好者的青睐. 一般有J2SE J2EE等.

Java简介

Java 是 Sun 公司推出的一种编程语言。它是一种通过解释方式来执行的语言，语法规则和 C++ 类似。

同时， Java 也是一种跨平台的程序设计语言。用 Java 语言编写的程序叫做 “Applet” （小应用程序），用编译器将它编译成类文件后，将它存在 WWW 页面中，并在 HTML 档上作好相应标记，用户端只要装上 Java 的客户软件就可以在网上直接运行 “Applet” 。 Java 非常适合于企业网络和 Internet 环境，现在已成为 Internet 中最受欢迎、最有影响的编程语言之一。 Java 有许多值得称道的优点，如简单、面向对象、分布式、解释性、可靠、安全、结构中立性、可移植性、高性能、多线程、动态性等。 Java 摈弃了 C++ 中各种弊大于利的功能和许多很少用到的功能。 Java 可以运行与任何微处理器，用 Java 开发的程序可以在网络上传输，并运行于任何客户机上。 JAVA的特点

Java是一种跨平台，适合于分布式计算环境的面向对象编程语言。具体来说，它具有如下特性：简单性、面向对象、分布式、解释型、可靠、安全、平台无关、可移植、高性能、多线程、动态性等。下面我们将重点介绍Java语言的面向对象、平台无关、分布式、多线程、可靠和安全等特性。
- 面向对象

面向对象其实是现实世界模型的自然延伸。现实世界中任何实体都可以看作是对象。对象之间通过消息相互作用。另外，现实世界中任何实体都可归属于某类事物，任何对象都是某一类事物的实例。如果说传统的过程式编程语言是以过程为中心以算法为驱动的话，面向对象的编程语言则是以对象为中心以消息为驱动。用公式表示，过程式编程语言为：程序=算法+数据；面向对象编程语言为：程序=对象+消息。

所有面向对象编程语言都支持三个概念：封装、多态性和继承，Java也不例外。现实世界中的对象均有属性和行为，映射到计算机程序上，属性则表示对象的数据，行为表示对象的方法（其作用是处理数据或同外界交互）。所谓封装，就是用一个自主式框架把对象的数据和方法联在一起形成一个整体。可以说，对象是支持封装的手段，是封装的基本单位。Java语言的封装性较强，因为Java无全程变量，无主函数，在Java中绝大部分成员是对象，只有简单的数字类型、字符类型和布尔类型除外。而对于这些类型，Java也提供了相应的对象类型以便与其他对象交互操作。

多态性就是多种表现形式，具体来说，可以用"一个对外接口，多个内在实现方法"表示。举一个例子，计算机中的堆栈可以存储各种格式的数据，包括整型，浮点或字符。不管存储的是何种数据，堆栈的算法实现是一样的。针对不同的数据类型，编程人员不必手工选择，只需使用统一接口名，系统可自动选择。运算符重载（operator overload)一直被认为是一种优秀的多态机制体现，但由于考虑到它会使程序变得难以理解，所以Java最后还是把它取消了。

继承是指一个对象直接使用另一对象的属性和方法。事实上，我们遇到的很多实体都有继承的含义。例如，若把汽车看成一个实体，它可以分成多个子实体，如：卡车、公共汽车等。这些子实体都具有汽车的特性，因此，汽车是它们的"父亲"，而这些子实体则是汽车的"孩子"。Java提供给用户一系列类（class），Java的类有层次结构，子类可以继承父类的属性和方法。与另外一些面向对象编程语言不同，Java只支持单一继承。

Java是平台无关的语言是指用Java写的应用程序不用修改就可在不同的软硬件平台上运行。平台无关有两种：源代码级和目标代码级。C和C++具有一定程度的源代码级平台无关，表明用C或C++写的应用程序不用修改只需重新编译就可以在不同平台上运行。

Java主要靠Java虚拟机（JVM）在目标码级实现平台无关性。JVM是一种抽象机器，它附着在具体操作系统之上，本身具有一套虚机器指令，并有自己的栈、寄存器组等。但JVM通常是在软件上而不是在硬件上实现。（目前，SUN系统公司已经设计实现了Java芯片，主要使用在网络计算机NC上。另外，Java芯片的出现也会使Java更容易嵌入到家用电器中。）JVM是Java平台无关的基础，在JVM上，有一个Java解释器用来解释Java编译器编译后的程序。Java编程人员在编写完软件后，通过Java编译器将Java源程序编译为JVM的字节代码。任何一台机器只要配备了Java解释器，就可以运行这个程序，而不管这种字节码是在何种平台上生成的（过程如图1所示）。另外，Java采用的是基于IEEE标准的数据类型。通过JVM保证数据类型的一致性，也确保了Java的平台无关性。

Java的平台无关性具有深远意义。首先，它使得编程人员所梦寐以求的事情（开发一次软件在任意平台上运行）变成事实，这将大大加快和促进软件产品的开发。其次Java的平台无关性正好迎合了"网络计算机"思想。如果大量常用的应用软件（如字处理软件等）都用Java重新编写，并且放在某个Internet服务器上，那么具有NC的用户将不需要占用大量空间安装软件，他们只需要一个Java解释器，每当需要使用某种应用软件时，下载该软件的字节代码即可，运行结果也可以发回服务器。目前，已有数家公司开始使用这种新型的计算模式构筑自己的企业信息系统。
- 分布式
Java支持WWW客户机/服务器计算模式，因此，它支持这两种分布性。对于前者，Java提供了一个叫作URL的对象，利用这个对象，你可以打开并访问具有相同URL地址上的对象，访问方式与访问本地文件系统相同。对于后者，Java的applet小程序可以从服务器下载到客户端，即部分计算在客户端进行，提高系统执行效率。
Java提供了一整套网络类库，开发人员可以利用类库进行网络程序设计，方便得实现Java的分布式特性。
分布式包括数据分布和操作分布。数据分布是指数据可以分散在网络的不同主机上，操作分布是指把一个计算分散在不同主机上处理。

- 可靠性和安全性
Java最初设计目的是应用于电子类消费产品，因此要求较高的可靠性。Java虽然源于C++，但它消除了许多C++不可靠因素，可以防止许多编程错误。首先，Java是强类型的语言，要求显式的方法声明，这保证了编译器可以发现方法调用错误，保证程序更加可靠；其次，Java不支持指针，这杜绝了内存的非法访问；第三，Java的自动单元收集防止了内存丢失等动态内存分配导致的问题；第四，Java解释器运行时实施检查，可以发现数组和字符串访问的越界，最后，Java提供了异常处理机制，程序员可以把一组错误代码放在一个地方，这样可以简化错误处理任务便于恢复。

由于Java主要用于网络应用程序开发，因此对安全性有较高的要求。如果没有安全保证，用户从网络下载程序执行就非常危险。Java通过自己的安全机制防止了病毒程序的产生和下载程序对本地系统的威胁破坏。当Java字节码进入解释器时，首先必须经过字节码校验器的检查，然后，Java解释器将决定程序中类的内存布局，随后，类装载器负责把来自网络的类装载到单独的内存区域，避免应用程序之间相互干扰破坏。最后，客户端用户还可以限制从网络上装载的类只能访问某些文件系统。上述几种机制结合起来，使得Java成为安全的编程语言。

- 多线程
线程是操作系统的一种新概念，它又被称作轻量进程，是比传统进程更小的可并发执行的单位。C和C++采用单线程体系结构，而Java却提供了多线程支持。

Java在两方面支持多线程。一方面，Java环境本身就是多线程的。若干个系统线程运行负责必要的无用单元回收，系统维护等系统级操作；另一方面，Java语言内置多线程控制，可以大大简化多线程应用程序开发。Java提供了一个类Thread，由它负责启动运行，终止线程，并可检查线程状态。Java的线程还包括一组同步原语。这些原语负责对线程实行并发控制。利用Java的多线程编程接口，开发人员可以方便得写出支持多线程的应用程序，提高程序执行效率。必须注意地是，Java的多线程支持在一定程度上受运行时支持平台的限制。例如，如果操作系统本身不支持多线程，Java的多线程特性可能就表现不出来。
参考资料：http://bbs.inzone.cn/viewthread.php?tid=7461

❻ java 小问题 子类的子类是父类的子类还是间接子类

你应该这样去理解 “所有“ 的 Exception 类。

在 java 中 java.lang.Exception 是 java.lang.Throwable 的子类，而 java.lang.RuntimeException 也是 java.lang.Throwable 的子类。

因此，如果有一段代码，不管是会发生 Exception 还是 RuntimeException ，而你想一次性捕获所有错误的时候，这样写：

publicstaticvoidmain(String[]args){
System.out.println("----------测试输出1----------");
try{
Strings=null;
//注：这一个会抛出NullPointException，即RuntimeException的子类。
s=s.substring(0);
}catch(Throwableex){
ex.printStackTrace();
}
System.out.println("----------测试输出2----------");
try{
Strings="123";
//注：这一个会抛出IndexOutOfBoundsException，即RuntimeException的子类。
inti=s.indexOf(200);
}catch(Throwableex){
ex.printStackTrace();
}
System.out.println("----------测试输出3----------");
}

你在上面的代码里面可以看到，即使是发生了 RuntimeException ，但是使用了 Throwable 也可以捕获到，而且你不用关心具体是什么原因出错了，只要有错误，用 Throwable 都可捕获到。

如果不使用 Throwable ，又是一个什么情况呢，这个时候，你就需要在程序中针对某一个 Exception 或 RuntimeException 来写 catch 了：

publicstaticvoidmain(String[]args){
System.out.println("----------测试输出4----------");
try{
Strings=null;
//注：这一个会抛出NullPointException，即RuntimeException的子类。
s=s.substring(0);
}catch(NullPointExceptionex){
ex.printStackTrace();
}
System.out.println("----------测试输出5----------");
try{
Strings="123";
//注：这一个会抛出IndexOutOfBoundsException，即RuntimeException的子类。
inti=s.indexOf(200);
}catch(IndexOutOfBoundsExceptionex){
ex.printStackTrace();
}
System.out.println("----------测试输出6----------");
}

但是，其实所有 RuntimeException 及其子类都不需要在程序中显式调用的，如果不进行显式调用，则表明你不需要理会错误，当有任何错误发生时，让程序自动终止：

publicstaticvoidmain(String[]args){
System.out.println("----------测试输出7----------");

Strings=null;
//注：这一个会抛出NullPointException，即RuntimeException的子类。
s=s.substring(0);

System.out.println("----------测试输出8----------");

Strings="123";
//注：这一个会抛出IndexOutOfBoundsException，即RuntimeException的子类。
inti=s.indexOf(200);

System.out.println("----------测试输出9----------");}

这个时候，在上面代码中，因为没有进行 catch ，所以，第 2 句 “测试输出 8” 就不会执行到了。

❼ java什么叫子类

父子类：存在继承关系，关键字extends，例如你说的：classSonextendsFather{Stringname；}儿子是父亲的一个子类，是两个独立的类，只是子类继承父类的成员变量和成员方法

内部类：与继承无关，是定义在一个类内部的类，可以看成是类的一部分，分为：

例如：classFather{{}}这个表示“父亲的衣服FatherClother”定义在父亲类里面(没有继承关系)，并继承衣服类Clother（有继承关系）

此时“父亲的衣服类”可以看成是父亲类的一个一个成员变量，但他们没有继承关系，可以写成：Father.FatherCloter，而那个“.”，表示成员运算符表示FatherClother是Father的一个成员，就像上面Son类中的Son.name一样，但是我们不能写成Father.Son。

所以楼主说的“classa1extendsa2{}那么a1是a2的子类吗？”是对的。

“我们写B1.B2.C3(中间是点号)的时候，就表示c3是b2的子类，b2是b1的子类？”不是子类，是内部类

“那classa1{classa2{}}这样a2也是a1的子类吗？也可以写成a1.a2？”不是子类，是内部类

内部类在解决这样的问题的时候，很有用（当然只是一个方面，还有别的用处）：

一个接口A中有p（）方法，一个类B中也有p（）方法，那么我想让这个接口被B实现，然后调用p（）方法（B类中的p（）方法，我不想覆盖），但是我们调用的哪个？

此时我们可以在B的内部声明一个内部类C，让C去实现A接口，然后调用B中原有的p（）方法，可以用B的对象b.p（），调用接口中被实现的p（）方法，可以b..c.p（）（c是类C的一个实例）

继承，太熟悉了，熟悉到都不知道说什么了，只能想到这么一句：继承意味着基于一个已经定义好的类创建一个新的类，新的类将以某种方式扩展原有的类，可以认为就是一个类得到另一个类所有属性的过程（构造函数木有被继承，但子类可以通过super调用）。

后面还有匿名内部类，有兴趣可以网络一下了解了解。

❽ java中子类和子类型的区别

子类化(subclass) 和 子类型化(subtype)的区别[原创，未经作者许可不得转载]

subtype具有更加严格的要求，就是父类的任何子类都可以在运行时可无缝的代替父类的工作，子类的接口具有更加相比父类更加强的前置条件，父类的接口在子类中得到继承，并且不得在子类中修改父类方法的签名.子类型化的好处是实现依赖倒置，参见参考读物的Bicycle一图，

subclass主要目的为了更加方便的重用，通常不需要符合Is-a的要求，如果采用组合，那么必须手写大量接口，然后Delegate给这个成员变量，如果父类很大的话，使用组合需要大量的工作量，而采用继承则方便很多，另外通过继承可以访问protected的成员及其方法，这也是组合所不具备的。

❾ JAVA子类构造方法

首先指出一点不足：
构造方法最好是指明访问权限。
一般是public的，如果是不想被外界调用可以设置为private的比如以后你会学到设计模式中的单例模式，或者是protected只允许本类本包和子类调用，如果什么都不写就像你的例子中那样默认是只允许本类本包。如果你是刻意省略，建议养成习惯还是写上public或者你需要的对应的访问权限。
再者，解决你的疑惑：
你问“怎么在子类中运用父类的Super方法？？？？？子类不是继承了父类吗？”。
在子类中调用父类的方法还有很多种情况的，比如你“super(1,2);”调用父类的构造方法，是很正确的。这里要首先注意一点，构造方法是不会被继承的包括后来会学到的析构方法。所以，子类继承不了父类的构造方法（无论是什么权限），想要调用，那么可以，只能通过super来调用。
那么继承不了构造方法，子类可以继承么呢？一句话，子类可以继承父类的所有非private的成员，这里说的成员指的是属性和方法。比如父类有个非private的fun()方法，那么子类可以通过super.fun()来调用或者直接一个fun()来调用，为么，因为子类已经继承了父类的了，fun()不仅是爹爹的而且还是自己的。或者子类可以重写父类的方法，重写fun()，那么子类重写了父类的fun()了，这时候可以通过this.fun()和super.fun()来分别调用子类和父类的fun()，但是这种情况并不常见。最常用的就是使用super调用父类的构造方法除此super并不常用了。

❿ 怎么分java中的主类和子类

好像只有父类和子类吧。extends前面的类叫父类，extends后面的叫子类，二者是继承关系。整个程序只有一个主方法，就是main方法。但是类有很多。