9.30动手动脑
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 Text1 { 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); } }
运行结果：
Hello
100
Information
public class Txet2 { public static void main(String []args) { int value1=100; int value2=100; System.out.println(value1==value2); } }
结果为：true
public class Txet2 { public static void main(String []args) { MyClass c1=new MyClass(); MyClass c2=new MyClass(); System.out.println(c1==c2); } } 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; } }
结果为：false
原因是：
当“==”施加于原始数据类型变量时，是比较变量所保存的数据是否相等
当“==”施加于引用类型变量时，是比较这两个变量是否引用同一对象。
引用代表地址，所以“==”实际上相当于比较两个引用类型变量中保存的对象地址是否相同。
public class Text3 { 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; } }
结果为：
false
true
该方法称为类的“构造方法”，有时也习惯称为“构造函数”。
当创建一个对象时，它的构造方法会被自动调用。构造方法与类名相同，没有返回值。
如果类没有定义构造函数，Java编译器在编译时会自动给它提供一个没有参数的“默认构造方法”。
报错的原因为：如果类提供了一个自定义的构造方法，将导致系统不再提供默认构造方法。
public class Text4 { public static void main(String []args) { Intnate it=new Intnate(); System.out.println(it.fi); it=new Intnate(300); System.out.println(it.fi); } } class Intnate{ { fi=200; } public int fi=100; public Intnate() {} public Intnate(int a) { this.fi=a; } }
结果为：
100
300
执行类成员定义时指定的默认值或类的初始化块，到底执行哪一个要看哪一个“排在前面”。
执行类的构造函数。类的初始化块不接收任何的参数，而且只要一创建类的对象，它们就会被执行。因此，适合于封装那些“对象创建时必须执行的代码”。
public class TextStatic { public static void main(String[] args) { new Leaf(); } } 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的构造器"); } }
结果：
Root的静态初始化块
Mid的静态初始化块
Leaf的静态初始化块
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：Java初始化顺序演示
Leaf的普通初始化块
执行Leaf的构造器
静态初始化块的执行顺序：静态初始化块只执行一次。创建子类型的对象时，也会导致父类型的静态初始化块的执行。
类的静态方法只能访问静态成员。
静态方法中只允许访问静态数据，那么，如何在静态方法中访问类的实例成员（即没有附加static关键字的字段或方法）?
public class Textjingtai { public static void main(String[] args) { T t=new T(); t.gets(); } } class T { int x=3; static int y=4; public static void gets() { System.out.println("变量x = " + new T().x); System.out.println("变量y = " + y); }}
在静态方法中对该类进行实例化进行对实例变量的访问。
