例一：
public class Tryha{
public static void main(String args[]){
Pt pt;
pt=new Pt();
pt.age=10;
pt.shout();
}
}
class Pt{
int age;
void shout(){
System.out.print("age is "+age+" ");
}
void thingsoutstatic(){
System.out.println("method useful in constructor");
}
public Pt(){
void haha(){
System.out.println("can creat a method here? No");
}
}
}
当按照上面的方法书写时，程序提示错误， 提示Syntax error on token(s), misplaced construct(s)
修改后如下：
public class Tryha{
public static void main(String args[]){
Pt pt;
pt=new Pt();
pt.age=10;
pt.shout();
}
}
class Pt{
int age;
void shout(){
System.out.print("age is "+age+" ");
}
void thingsoutstatic(){
System.out.println("method useful in constructor");
}
public Pt(){
/* void haha(){
System.out.println("can creat a method here? No");
}*/
}
}
程序成功运行， 得到：age is 10
结论：constructor 有两个方面的特性：一是名字得和class 得名字一致，二是它是一种特殊的方法（因此具有一般方法的特性），特别之处在于它不会返回值。在java 里面， 方法是不可以嵌套创建的， 如果要在一个方法里面用到新的方法， 得通过call, 而不是直接建立一个新的方法在里面而产生像上面那样的错误。
例二：
public class Tryha{
public static void main(String args[]){
Pt pt;
pt=new Pt();
pt.age=10;
// pt.shout();
}
}
class Pt{
int age;
void shout(){
System.out.print("age is "+age+" ");
}
void thingsoutstatic(){
System.out.println("method useful in constructor");
}
public Pt(){
thingsoutstatic();
}
}
能够成功运行，结果：method useful in constructor
结论：在constructor 里面， 我们能够去call 另一个方法， 当对象被创建时， 就会call constructor, constrctor 里面的任何属性（呵呵，这个属性好像是属于该class 的， 不是construcor单独拥有的，constructor 也是class 的属性呢！）都开始copy 到对象中，包括constructor 里面所call的方法， 简单一点说：constructor 是一种特殊的属性，在每次创建对象时， 就会将该类的属于promitive data type 的属性copy 到对象空间中，并在对象空间中创建一个reference的空间指向该constructor.
例三：
public class Tryha{
public static void main(String args[]){
Pt pt;
pt=new Pt();
pt.age=10;
// pt.shout();
}
}
class Pt{
int age;
void shout(){
System.out.print("age is "+age+" ");
}
void thingsoutstatic(){
System.out.println("method useful in constructor");
}
public Pt(){
shout();
}
}
运行结果：age is 0
结论：如果方法在constructor 里面， 就是任何方法运行结果都回一模一样，值也不会有变化，而constructor 里涉及到的变量的值就会是class 属性， 而不是对象属性。要打印出变量属性， 得直接call shout() method.
例四：
public class Tryha{
public static void main(String args[]){
Pt pt;
pt=new Pt();
pt.age=10;
pt.shout();
}
}
class Pt{
int age;
void shout(){
System.out.print("age is "+age+" ");
}
void thingsoutstatic(){
System.out.println("method useful in constructor");
}
public Pt(){
}
}
运行结果：age is 10
结论：对象现将类的值储存（此时已经从类的属性变成对象的属性了）， 然后可以修改成自己单独拥有的值，从自己这里call 的方法当然是属于自己的，于是所使用的属性自然也是对象的属性了。（把constructor 当成一张设计图，class 想成构思，object 想成具体物体， 那么call constructor 时就是直接使用的这个构思的设计图， 而call object 得method 时， 该实现的方法也都得到实现了 ， 当然得用object 自己的东西了）好难啰嗦清楚！！！
例五：
public class Tryha{
public static void main(String args[]){
Pt1 pt1;
pt1=new Pt1();
}
}
class Pt{
int age;
void shout(){
System.out.print("age is "+age+" ");
}
void thingsoutstatic(){
System.out.println("method useful in constructor");
}
public Pt(){
System.out.println("super constructor");
}
}
class Pt1 extends Pt{
public Pt1(){
System.out.println("child constructor");
}
}
结果显示:
super constructor
child constructor
结论：每一个子类的对象创建都会先call 父类的构造器，然后在call 子类的构造器 （绝对不存在什么子类构造器覆盖父类构造器的问题哦，像一像，子类的产生本来就要有父类的构造器嘛，而且子类不就是根据父类来的吗？那么通知父类一声也是应该的， 呵呵，版权问题嘛！）
例六：
public class Tryha{
public static void main(String args[]){
Pt1 pt1;
pt1=new Pt1(5);
}
}
class Pt{
int age;
void shout(){
System.out.print("age is "+age+" ");
}
void thingsoutstatic(){
System.out.println("method useful in constructor");
}
public Pt(){
System.out.println("super constructor");
}
public Pt(int a){
System.out.println("super constructor 2 ");
}
}
class Pt1 extends Pt{
public Pt1(int a){
System.out.println("child constructor");
}
}
结果显示:
super constructor
child constructor
结论：和子类constructor 的parameter无关，只要父类中存在super(), 而你在子类的构造器中没有特别去call 其他的super(int a)这种带parameter 的构造器，那么在产生子类对象时， 所调用的就是先call super(), 然后在子类。
例七：
public class Tryha{
public static void main(String args[]){
Pt1 pt1;
pt1=new Pt1(5);
}
}
class Pt{
int age;
void shout(){
System.out.print("age is "+age+" ");
}
void thingsoutstatic(){
System.out.println("method useful in constructor");
}
public Pt(int a){
System.out.println("super constructor 2 ");
}
}
class Pt1 extends Pt{
public Pt1(int a){
System.out.println("child constructor");
}
}
结果该程序不能运行，提示错误：Implicit super constructor Pt() is undefined. Must explicitly invoke another constructor
结论：如果在子类里没有call 父类的constructor, 那么它会自己去call super() 这个constructor, 此时父类里必须存在constructor.
例八：
public class Tryha{
public static void main(String args[]){
Pt1 pt1;
pt1=new Pt1(5);
}
}
class Pt{
int age;
void shout(){
System.out.print("age is "+age+" ");
}
void thingsoutstatic(){
System.out.println("method useful in constructor");
}
public Pt(int a){
System.out.println("super constructor 2 ");
}
}
class Pt1 extends Pt{
public Pt1(int a){
super(a);
System.out.println("child constructor");
}
}
结果显示：
super constructor 2
child constructor
结论：在没有default 得super()存在的情况下，必须在子constructor 中call 父类已经存在的constructor.
例九：
public class Tryha{
public static void main(String args[]){
Pt1 pt1;
pt1=new Pt1(5);
}
}
class Pt{
int age;
void shout(){
System.out.print("age is "+age+" ");
}
void thingsoutstatic(){
System.out.println("method useful in constructor");
}
public Pt(int a){
System.out.println("super constructor 2 ");
}
}
class Pt1 extends Pt{
public Pt1(int a){
super(int c);
System.out.println("child constructor");
}
}
程序错误， 提示Syntax error on token "int", delete this token， 但是一旦delete int 后，就会提示c cannot be resolved
结论：不要忘记了在java 中任何变量在使用前都得初始化（class 得properties 可以不用开始赋值，因为class 会自动初始化所有的properties, 但是你要初始化也是可以的）， 在上面的例子九中，运行到super (int c )时， 程序发现c并没有值，所以程序报错。
例十：
public class Tryha{
public static void main(String args[]){
Pt1 pt1;
pt1=new Pt1(5);
}
}
class Pt{
int age;
void shout(){
System.out.print("age is "+age+" ");
}
void thingsoutstatic(){
System.out.println("method useful in constructor");
}
public Pt(int a){
System.out.println("super constructor 2 ");
}
}
class Pt1 extends Pt{
int c=0;
public Pt1(int a){
super(c);
System.out.println("child constructor");
}
}
程序出错， 提示Cannot refer to an instance field c while explicitly invoking a constructor
可以修改为:
public class Tryha{
public static void main(String args[]){
Pt1 pt1;
pt1=new Pt1(5);
}
}
class Pt{
int age;
void shout(){
System.out.print("age is "+age+" ");
}
void thingsoutstatic(){
System.out.println("method useful in constructor");
}
public Pt(int a){
System.out.println("super constructor 2 ");
}
}
class Pt1 extends Pt{
static int c=0;
public Pt1(int a){
super(c);
System.out.println("child constructor");
}
}
为什么这里加上static 后程序就没有问题了？
猜测原因是：有constructor不一定表示创建了对象， （储存对象字段的空间和static 字段的空间是不相同的），而在constructor中指向instance data field 实例字段是不安全的， 因为这个实例 有可能根本就不存在， 而static 并不属于对象空间， 所以static可行。
本文转载自-和讯博客-Robin's Blog-ousys
分享到：
相关推荐
### Java反射操作父类所有属性和方法 #### 一、引言 在Java编程语言中，反射（Reflection）是一项强大的特性，它允许程序在运行时动态地获取类的信息，并能够直接操作这些信息。通过反射，我们可以获取类的字段、...
总结一下，`Object.getPrototypeOf`是JavaScript中用于获取对象原型的关键工具，它在子类调用父类方法时起到了桥梁的作用。通过理解原型链的工作原理，我们可以更有效地实现继承和代码复用。在实际开发中，正确地...
Java 反射机制中的 Constructor 类提供了关于类的单个构造方法的信息，包括对它的访问权限、Class 获取构造函数的方式等。下面将详细讲解 Constructor 类的概述、获取构造函数的方式、构造类的实例概述等。 ...
本篇文章将深入探讨如何在NDK环境中调用Java的构造方法、父类方法以及处理Java返回的中文字符串可能出现的乱码问题。 首先，让我们了解一下在C/C++中调用Java的方法。这主要依赖于JNI（Java Native Interface）。...
在Java中，**运行时类型信息**（RTTI）是指程序能够在运行时获取并使用对象和类的类型信息。这使得开发者可以在运行时动态地创建对象、调用方法或访问字段。RTTI主要通过两种方式实现： 1. **传统RTTI**：假设在...
在Java中，反射机制的核心类是`java.lang.Class`，它代表了类的信息。当我们需要在运行时动态地获取类的信息或者创建对象时，就会用到反射。 首先，我们可以通过`Class`类的`forName()`静态方法来获取一个类的`...
在Java中，反射机制主要用到了java.lang.Class、java.lang.reflect.Method、java.lang.reflect.Field和java.lang.reflect.Constructor这四个类。下面我们将详细探讨Java反射的基本概念、使用场景以及如何通过`...
在Java中，`java.lang.reflect`包提供了Class、Field、Method和Constructor等类，用于获取类的信息和动态调用方法。当我们有一个类的对象，并且知道其类名或对象的类型时，我们可以使用反射来访问类的私有成员，包括...
java.lang.reflect.Constructor; java.lang.reflect.Field; java.lang.reflect.Method; java.lang.reflect.Modifier;
在Java中，子类可以继承父类的属性和方法。同样地，子类也可以继承父类的构造函数，这是通过构造函数调用来实现的。子类的构造函数可以通过`super()`来显式调用父类的构造函数。如果没有显式调用，则默认会调用父类...
Java中的`super`关键字用于在子类构造函数中显式调用父类的构造器。例如： ```java class Parent { public Parent() { System.out.println("Parent's constructor"); } } class Child extends Parent { public...
3. **函数与方法**：在Java中，函数和方法用于封装代码，提高代码复用性。实例将展示如何定义、调用和传递参数，以及理解返回值的概念。 4. **数组**：数组是存储同类型数据的集合，学习如何创建、初始化和操作数组...
由于实际的内容非常有限，我们将基于这个主题深入探讨Java中的继承概念，并提供一些基本的例子来帮助理解。 ### Java中的继承 #### 1. 继承的概念 在面向对象编程中，继承是一种创建新类的方式，这些新类可以继承...
- 这可以通过观察构造函数的输出顺序来验证，例如，在上述例子中，"base constructor"总是先于"derived constructor"打印出来。 4. **调用父类的非默认构造函数**： - 如果子类需要调用父类的非默认构造函数，...
这些实例不仅涵盖了Java语言的基础，还涉及了高级特性和现代Java开发中的常用技术，通过实践这些例子，开发者可以更好地理解和掌握Java编程。每个实例都是一个独立的小项目，通过阅读和运行代码，学习者能够加深对...
通过创建和使用类，你可以看到如何在Java中实现面向对象的设计原则。 3. **异常处理**：Java的异常处理是其强项之一，例子中可能会有try-catch-finally结构，用于捕获和处理程序运行时可能出现的错误。 4. **集合...
deriveClass.java 子类访问父类变量示例 getLinePara.java 获取命令行参数示例 hasStaticMethod.java 静态成员方法示例 hasStatMember.java 静态成员变量示例 HelloNative.c 用C写的一个小程序 HelloNative....
在Java中，主要有以下四种类加载器： 1. BootStrapClassLoader：这是最基础的类加载器，负责加载JVM的核心类库，如rt.jar，这部分类库位于JRE的lib目录下，是JVM启动时必须加载的。 2. ExtClassLoader：扩展类加载...
在"如何通过JAVA中的反射加载某个类中的某个方法"和"[Java]读取文件方法大全"中，你可以了解到Java的各种文件读写方法，例如`FileReader`、`BufferedReader`用于文本文件读取，`FileOutputStream`、`FileInputStream...