例一：
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的反射的一个组件Constructor的描述和讲解
java.lang.reflect.Constructor; java.lang.reflect.Field; java.lang.reflect.Method; java.lang.reflect.Modifier;
deriveClass.java 子类访问父类变量示例 getLinePara.java 获取命令行参数示例 hasStaticMethod.java 静态成员方法示例 hasStatMember.java 静态成员变量示例 HelloNative.c 用C写的一个小程序 HelloNative....
附件是自己总结在编程过程中所遇到的关于反射的内容，主要是详细的描述了关于Constructor、Mehod、Field和Class类的内容
1. 构造函数 default constructor：在JAVA中，如果一个类中未显式定义构造函数，那么系统将自动提供一个默认的无参构造函数，函数体为空。 2. 常量定义：在JAVA中，使用final关键字来定义一个常量，而不是const...
在 Java 中,this 和 super 是两个重要的关键字，它们都是用于访问当前对象或父类中的成员变量或方法的。 this 用法 this 的用法在 Java 中大体可以分为三种： 1. 普通的直接引用 在类的成员方法中，可以使用 ...
java reflect Method getDeclaredMethod invoke getConstructor
在 Java 中，子类父类的加载顺序是： 1. 创建第一个子类对象时：父类静态块->被调子类静态块->父类动态块->父类无参构造器->被调子类动态块->被调子类无参构造器 2. 创建第一个另一个子类对象时：被调子类静态块->...
import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; import com.org.entity.User; /** */ public class Test3 { /** * @param args */ public static void main(String[] args) ...
1. Object类的所有方法及功能：Object类是Java中的顶层类，所有类实际上都继承了Object类的所有方法。Object类提供了以下方法： * protected Object clone()：用于获得此对象的一个拷贝 * public Boolean equals...
子类不会覆盖父类的构造函数，相反必须负责在一开始调用父类的构造函数。 4. break、continue、return语句 break跳出总上一层循环，不再执行循环(结束当前的循环体)；continue跳出本次循环，继续执行下次循环(结束...
9.Java中访问数据库的步骤，Statement和PreparedStatement之间的区别。 10.找出下列代码可能存在的错误，并说明原因： 二、JSP&Servlet技术 1.描述JSP和Servlet的区别、共同点、各自应用的范围 2.在Web开发中...
反射之操作Constructor 构造方法类分析.md
C#例子代码 A0013_OO_ConstructorC#例子代码 A0013_OO_ConstructorC#例子代码 A0013_OO_ConstructorC#例子代码 A0013_OO_ConstructorC#例子代码 A0013_OO_ConstructorC#例子代码 A0013_OO_ConstructorC#例子代码 A...
在Java中，存在五种访问权限控制等级，从最宽松到最严格控制等级依次是：public、default、protected、private。这些访问权限控制可以控制类、方法和变量的访问范围。 集合框架 Java集合框架中，常用的两个List的...
Watchface-Constructor Please check [our article] (https://yalantis.com/blog/building-a-customizable-constructor-for-designers-of-android-wear-watch-face-apps) This is simple watchface constructor ...
3.4 小结：基本数据类型—— Java中一切数据和运算的基础 63 3.5 习题 65 第4章 Java中的程序执行流程 67 教学视频：1小时57分钟 4.1 顺序执行 67 4.2 使用if-else让程序懂得判断 68 4.2.1 if语句 68 4.2.2 ...
子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。...
3.4 小结：基本数据类型—— Java中一切数据和运算的基础 63 3.5 习题 65 第4章 Java中的程序执行流程 67 教学视频：1小时57分钟 4.1 顺序执行 67 4.2 使用if-else让程序懂得判断 68 4.2.1 if语句 68 4.2.2 ...
Class 类代表了 Java 中的一个类，而 java.lang.reflect 包提供了许多反射类，例如 Constructor、Method、Field 等。 Constructor 类代表了某个类中的一个构造方法。例如，我们可以使用 Class.forName("java.lang....