2022.9.30 Java第四次课后总结

1.
public class BoxAndUnbox {

/**
* @param args
*/
public static void main(String[] args) {
int value=100;

Integer obj=value; //装箱

int result=obj*2; //拆箱

}

}

创建了一个value 并定义了相关变量

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;
}

}

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(){

}
}

动手动脑部分

package p;

import java.util.Scanner;

public class StaticMethod {

        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);
            }
        }
        static 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();

            }
        }
}
运行结果如下

类的静态方法只能访问类的静态成员

类的静态方法是不能直接访问实例的成员的，它只能访问同类的静态成员。访问实例的成员的话，可以参考一下这个方法，那就是把静态方法的参数设置为类的实例，这样通过参数传递的方式就可以访问实例的成员了，例子如下：

 package trr;
 2
 3 public class trr {
 4
 5     public static void main(String[] args) {
 6     x w;
 7     w=new x();
 8     x.show(w);//直接用类名调用静态方法
 9     }
10
11 }
12  class x
13 {
14
15 int num=10;
16 static void show(x n) //参数设置为类的实例
17
18
19 {
20     System.out.println(n.num);    //访问实例的成员
21 }
22
23 }

装箱过程是通过调用包装器的valueOf方法实现的
拆箱过程是通过调用包装器的xxxValue方法实现的（xxx表示对应的基本数据类型）
Byte、Short、Integer、Long这几个类的valueOf方法实现类似的。所以在[-128,127]区间内，==比较的时候，值总是相等的（指向的是同一对象），在这个区间外是不等的。
而Float和Double则不相等， Boolean的值总是相等的
equals()：比较两个对象的值（内容）是否相同
”==“：比较两个对象的引用（内存地址）是否相同，也用来比较两个基础数据类型的变量值是否相等。