类与对象—动手动脑
1.验证ClassAndObjectTest.java（使用自定义类）
public class ClassAndObjectTest { public static void main(String[] args) { //创建类的实例，定义一个对象变量引用这一实例 MyClass obj = new MyClass(); //通过对象变量调用类的公有方法 obj.myMethod("Hello"); //给属性赋值 obj.setValue(100); //输出属性的当前值 System.out.println(obj.getValue()); //直接访问对象公有字段 obj.Information = "Information"; //输出对象公有字段的当前值 System.out.println(obj.Information); } } /** * 自定义Java类的示例 */ class MyClass { // 公有字段 public String Information = ""; // 自定义公有Java实例方法 public void myMethod(String argu) { System.out.println(argu); }// 定义属性：私有字段+get方法+set方法 private int value; public int getValue() { return value; } public void setValue(int value) { this.value = value; } }
运行结果：
2.早期我们经常这样定义变量“int value=100;”,而前面的示例中这样定义变量“MyClass obj=new MyClass();”,这两种方式定义的变量是一样的吗？
不一样。当声明一个对象类型的变量时,实际上并没有创建一个对象，此变量=null。定义一个原始类型的变量时,会马上给其分配内存。而且引用对象后的对象变量，如果不再使用此变量，JVM会回收MyClass对象所占用的内存（垃圾回收）。
3.对于原始数据类型的变量（比如int)，可以直接使用“==”判断两变量值是否相等，那么对象变量也可以使用“==”判断两变量值是否相等吗？
public class Test { public static void main(String[] args) { // TODO Auto-generated method stub Foo obj1 = new Foo(); Foo obj2 = new Foo(); System.out.println(obj1==obj2); } } class Foo{ int value=100; }
运行结果：
正确代码：
public class ObjectEquals { public static void main(String[] args) { MyTestClass obj1=new MyTestClass(100); MyTestClass obj2=new MyTestClass(100); System.out.println(obj1==obj2); System.out.println(obj1.equals(obj2)); } } class MyTestClass { public int Value; //注意：只有参数类型为Object的，才是重写了Object的equals方法 //参数类型为MyTestClass的，仅仅是Overload了equals方法。 // @Override // public boolean equals(Object obj) // { // return ((MyTestClass)obj).Value==this.Value; // } public boolean equals(MyTestClass obj) { return obj.Value==this.Value; } public MyTestClass(int initValue) { Value=initValue; } }
==
原始数据类型：判断数据值和地址。 引用类型：判断数据值。
equals()
原始数据类型和引用类型都是判断数据值。
4.重写基类的equals()方法？重载equals()方法？
#
public class ObjectEquals { public static void main(String[] args) { MyTestClass obj1=new MyTestClass(100); MyTestClass obj2=new MyTestClass(100); System.out.println(obj1==obj2); System.out.println(obj1.equals(obj2)); } } class MyTestClass { public int Value; //注意：只有参数类型为Object的，才是重写了Object的equals方法 //参数类型为MyTestClass的，仅仅是Overload了equals方法。 @Override public boolean equals(Object obj) { return ((MyTestClass)obj).Value==this.Value; } /* public boolean equals(MyTestClass obj) { return obj.Value==this.Value; }*/ public MyTestClass(int initValue) { Value=initValue; } }
#
public class ObjectEquals { public static void main(String[] args) { MyTestClass obj1=new MyTestClass(100); MyTestClass obj2=new MyTestClass(100); System.out.println(obj1==obj2); System.out.println(obj1.equals(obj2)); } } class MyTestClass { public int Value; //注意：只有参数类型为Object的，才是重写了Object的equals方法 //参数类型为MyTestClass的，仅仅是Overload了equals方法。 public boolean equals(MyTestClass obj) { return obj.Value==this.Value; } public MyTestClass(int initValue) { Value=initValue； } }
5.以下代码为何无法通过编译？哪儿出错了？
如果类当中已经有了构造函数将不会自动调用默认的构造函数，即错在没有参数。
6.如果一个类中既有初始化块，又有构造方法，同时还设定了字段的初始值，谁说了算？
#字段初始值和类的初始化，哪个在前面执行哪个
如：
InitializeBlockClass obj=new InitializeBlockClass();//定义对象变量obj 创建new对象
输出—>200
InitializeBlockClass obj=new InitializeBlockClass();//定义对象变量obj 创建new对象
输出—>100
#构造函数的目的只有一个！很忠贞！
构造函数函数名和类名一样，会被自动调用。如果没有定义，系统会分配一个没有参数的构造函数。反正就是肯定会出现目的单纯且从不回头（初始化，没有返回值）的构造函数。
所以呢，如果有了构造函数，当然就会排除字段初始值和类的初始化。他是老大，老大说了算。
7.请运行TestStaticInitializeBlock.java示例，观察输出结果，总结出“静态初始化块的执行顺序”。
输出结果：
*静态变量在类创立时就分配一个内存空间，可以直接通过类名(对象名也可以！！！！写出例子)进行使用。但静态变量就只有一个内存空间，无论静态变量使用多少次，它都只有一个内存，相当于数据不断覆盖。
*而实例变量是在类创立后并且对象实例化之后才会分配内存空间，只能通过对象进行使用，并且有多少个对象就会有多少个内存。
所以在实例变量int y; public int getY(){return y;} 没有对象实例化时，是不能进行使用的，并且他也不能通过类名StaticDemo.getY()进行使用。这就是语法错误咯~然后就是静态变量为进行初始化的默认值：int类型是0，bool类型是false，对象是null。
8.静态方法中只允许访问静态数据，那么，如何在静态方法中访问类的实例成员（即没有附加static关键字的字段或方法）?
1.验证ClassAndObjectTest.java（使用自定义类） public class ClassAndObjectTest { public static void main(String[] args) { //创建类的实例，定义一个对象变量引用这一实例 MyClass obj = new MyClass(); //通过对象变量调用类的公有方法 obj.myMethod("Hello"); //给属性赋值 obj.setValue(100); //输出属性的当前值 System.out.println(obj.getValue()); //直接访问对象公有字段 obj.Information = "Information"; //输出对象公有字段的当前值 System.out.println(obj.Information); } } /** * 自定义Java类的示例 */ class MyClass { // 公有字段 public String Information = ""; // 自定义公有Java实例方法 public void myMethod(String argu) { System.out.println(argu); }// 定义属性：私有字段+get方法+set方法 private int value; public int getValue() { return value; } public void setValue(int value) { this.value = value; } } 其运行结果： 从结果来看，我们需要定义一个对象变量，然后“创建（new)”一个对象，赋值给对象变量。 2.早期我们经常这样定义变量“int value=100;”,而前面的示例中这样定义变量“MyClass obj=new MyClass();”,这两种方式定义的变量是一样的吗？ 不一样。 “引用”一个对象的变量称为“引用类型”的变量，有时又简称为“对象变量”。诸如int，float之类的变量称为“原始数据类型”的变量)。 从变量与内存分配上讲，当声明一个对象类型的变量时,实际上并没有创建一个对象，此变量=null。定义一个原始类型的变量时,会马上给其分配内存。 从变量的初始化上讲，在定义原始变量时，Java要求必须显式初始化变量；而对象变量的初始化：对象变量如果不引用一个真实的对象，则必须声明为null。 而且引用对象后的对象变量，如果不再使用此变量，JVM会回收MyClass对象所占用的内存（垃圾回收）。 3.对于原始数据类型的变量（比如int)，可以直接使用“==”判断两变量值是否相等，那么对象变量也可以使用“==”判断两变量值是否相等吗？ 验证相关程序： public class Test { public static void main(String[] args) { // TODO Auto-generated method stub Foo obj1 = new Foo(); Foo obj2 = new Foo(); System.out.println(obj1==obj2); } } class Foo{ int value=100; } 运行结果： 结论：不可以，类似于字符串的比较大小，使用equals()进行比较，用法与其相同。当“==”施加于引用类型变量时，是比较这两个变量是否引用同一对象。 引用代表地址，所以“==”实际上相当于比较两个引用类型变量中保存的对象地址是否相同。 所以，正确的代码如下： public class ObjectEquals { public static void main(String[] args) { MyTestClass obj1=new MyTestClass(100); MyTestClass obj2=new MyTestClass(100); System.out.println(obj1==obj2); System.out.println(obj1.equals(obj2)); } } class MyTestClass { public int Value; //注意：只有参数类型为Object的，才是重写了Object的equals方法 //参数类型为MyTestClass的，仅仅是Overload了equals方法。 // @Override // public boolean equals(Object obj) // { // return ((MyTestClass)obj).Value==this.Value; // } public boolean equals(MyTestClass obj) { return obj.Value==this.Value; } public MyTestClass(int initValue) { Value=initValue; } } 其运行结果如下： 4.重写基类的equals()方法？重载equals()方法？ ①重写基类的equals()方法： public class ObjectEquals { public static void main(String[] args) { MyTestClass obj1=new MyTestClass(100); MyTestClass obj2=new MyTestClass(100); System.out.println(obj1==obj2); System.out.println(obj1.equals(obj2)); } } class MyTestClass { public int Value; //注意：只有参数类型为Object的，才是重写了Object的equals方法 //参数类型为MyTestClass的，仅仅是Overload了equals方法。 @Override public boolean equals(Object obj) { return ((MyTestClass)obj).Value==this.Value; } /* public boolean equals(MyTestClass obj) { return obj.Value==this.Value; }*/ public MyTestClass(int initValue) { Value=initValue; } } 运行结果： ②重载equals()方法： public class ObjectEquals { public static void main(String[] args) { MyTestClass obj1=new MyTestClass(100); MyTestClass obj2=new MyTestClass(100); System.out.println(obj1==obj2); System.out.println(obj1.equals(obj2)); } } class MyTestClass { public int Value; //注意：只有参数类型为Object的，才是重写了Object的equals方法 //参数类型为MyTestClass的，仅仅是Overload了equals方法。 public boolean equals(MyTestClass obj) { return obj.Value==this.Value; } public MyTestClass(int initValue) { Value=initValue； } } 运行结果： 5.以下代码为何无法通过编译？哪儿出错了？ public class Test { public static void main(String[] args) { // TODO Auto-generated method stub Foo obj1 = new Foo(); } } class Foo{ int value; public Foo(int initValue){ value=initValue; } } 结论：如果类提供了一个自定义的构造方法，将导致系统不再提供默认构造方法。所以可以将“Foo obj1 = new Foo();”改为“Foo obj1 = new Foo(4);”。 6.如果一个类中既有初始化块，又有构造方法，同时还设定了字段的初始值，谁说了算？ 如： 在“public int field = 100;”在“{field=200;}”之前时，是“{field=200;}”说了算；在之后时，是“public int field = 100;”说了算。也就是谁比较靠后就是谁初始化起作用。 执行类成员定义时指定的默认值或类的初始化块，到底执行哪一个要看哪一个“排在前面”。执行类的构造函数。类的初始化块不接收任何的参数，而且只要一创建类的对象，它们就会被执行。因此，适合于封装那些“对象创建时必须执行的代码”。 具体程序如下： public class InitializeBlockDemo { /** * @param args */ public static void main(String[] args) { InitializeBlockClass obj=new InitializeBlockClass(); System.out.println(obj.field); obj=new InitializeBlockClass(300); System.out.println(obj.field); } } class InitializeBlockClass{ //下面这句在初始化块之前与之后，会影响到field字段的初始值 public int field=100;//在之前 { field=200; } //public int field=100;//在之后 public InitializeBlockClass(int value){ this.field=value; } public InitializeBlockClass(){ } } 运行结果： ①“public int field = 100;”在“{field=200;}”之前： ②“public int field = 100;”在“{field=200;}”之后： 结论：当有参数的函数赋了实参就输出实参计算出来的结果；如果是没有参数的函数，如果哪一种初始化靠后，就输出靠后的那一种初始化计算出来的结果。 7.请运行TestStaticInitializeBlock.java示例，观察输出结果，总结出“静态初始化块的执行顺序”。 class Root { static{ System.out.println("Root的静态初始化块"); } { System.out.println("Root的普通初始化块"); } public Root() { System.out.println("Root的无参数的构造器"); } } class Mid extends Root { static{ System.out.println("Mid的静态初始化块"); } { System.out.println("Mid的普通初始化块"); } public Mid() { System.out.println("Mid的无参数的构造器"); } public Mid(String msg) { //通过this调用同一类中重载的构造器 this(); System.out.println("Mid的带参数构造器，其参数值：" + msg); } } class Leaf extends Mid { static{ System.out.println("Leaf的静态初始化块"); } { System.out.println("Leaf的普通初始化块"); } public Leaf() { //通过super调用父类中有一个字符串参数的构造器 super("Java初始化顺序演示"); System.out.println("执行Leaf的构造器"); } } public class TestStaticInitializeBlock { public static void main(String[] args) { new Leaf(); } } 运行结果： 结论（静态初始化块的执行顺序）：静态初始化块只执行一次。创建子类型的对象时，也会导致父类型的静态初始化块的执行。 8.静态方法中只允许访问静态数据，那么，如何在静态方法中访问类的实例成员（即没有附加static关键字的字段或方法）? public class text4 { public static void main(String[] args) { // TODO Auto-generated method stub //静态 System.out.println("(静态变量)total_employees = "+Employee.clear()); //实例 Employee e = new Employee(); System.out.print("(实例变量)name = "+e.name); } } class Employee { String name = "lihui"; //long salary; //short employee_id; static int total_employees = 0; static int clear(){ return total_employees; } }
