首页 > 代码库 > JAVA作业 04 类与对象
JAVA作业 04 类与对象
一.动手动脑
1）题目要求：验证ClassAndObjectTest.java（使用自定义类）
2）源代码：
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 = http://www.mamicode.com/value;>
3）实验结果截图：
4）实验分析：从结果来看，我们需要定义一个对象变量，然后“创建（new)”一个对象，赋值给对象变量。
二.解决问题
早期我们经常这样定义变量“int value=http://www.mamicode.com/100;”,而前面的示例中这样定义变量“MyClass obj=new MyClass();”,这两种方式定义的变量是一样的吗？
不一样。
前者为“原始数据类型”，诸如int，float之类的变量；
后者为“引用类型”变量，“引用”一个对象的变量称为“引用类型”的变量，有时又简称为“对象变量”。
从变量与内存分配上讲，当声明一个对象类型的变量时,实际上并没有创建一个对象，此变量=null。定义一个原始类型的变量时,会马上给其分配内存。
从变量的初始化上讲，在定义原始变量时，Java要求必须显式初始化变量；而对象变量的初始化：对象变量如果不引用一个真实的对象，则必须声明为null。
而且引用对象后的对象变量，如果不再使用此变量，JVM会回收MyClass对象所占用的内存（垃圾回收）。
三 解决问题
对于原始数据类型的变量（比如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=http://www.mamicode.com/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=http://www.mamicode.com/=this.Value;>
其运行结果如下：
四.解决问题
如何比较两个对象的“内容”是否一样？
1）两个对象的“内容”，其实是指它们在某一时刻的所有字段的值，“内容相等”，其实是就“对应字段值”一致。在JAVA中要比对两个对象的字段值，可以 “重写（override）”基类的equals()方法；
注：当你定义一个类时，如果不显式指明它的“父亲”类是哪个，则默认是Object。Object是Java的最顶层基类，其中定义了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=http://www.mamicode.com/=this.Value;>
运行结果：
2）除了重写基类的equals方法，我们也可以“重载（overload）”equals( )方法：
注意：与前面“重写”方式的代码相比，equals( )方法的参数类型是MyTestClass而不是Object，并且方法本身也没有附加“@Override”标记。
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=http://www.mamicode.com/=this.Value;>
运行结果：
五.解决问题
以下代码为何无法通过编译？哪儿出错了？
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=http://www.mamicode.com/initValue;>
结论：如果类提供了一个自定义的构造方法，将导致系统不再提供默认构造方法。所以可以将“Foo obj1 = new Foo();”改为“Foo obj1 = new Foo(4);”。
六.解决问题
如果一个类中既有初始化块，又有构造方法，同时还设定了字段的初始值，谁说了算？
如：
在“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;}”之后：
七.解决问题
请运行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();
}
}
运行结果：
结论（静态初始化块的执行顺序）：静态初始化块只执行一次。创建子类型的对象时，也会导致父类型的静态初始化块的执行。
八.解决问题
静态方法中只允许访问静态数据，那么，如何在静态方法中访问类的实例成员（即没有附加static关键字的字段或方法）?
//静态方法中只允许访问静态数据，那么，如何在静态方法中访问类的实例成员（即没有附加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 = "2";
//long salary;
//short employee_id;
static int total_employees = 0;
static int clear(){
return total_employees;
}
static void clear2(){
}
}
运行结果：
JAVA作业 04 类与对象