类和对象,动手动脑

验证:TestStaticInitializeBlock.java

 

package CeShi;

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

 

 ClassAndObjectTest.java

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

 

 

 InitializeBlockDemo.java

 

package CeShi;
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(){
  
 }
}

 

 MyPackageClass.java

package CeShi;
public class MyPackageClass {
 public static String reverseString(String inputStr)
 {
  StringBuffer buff=new StringBuffer();
  
  for(int i=inputStr.length()-1;i>=0;i--)
   buff.append(inputStr.charAt(i));
   
  return buff.toString();
 }
}

 

 ObjectEquals.java

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

 

 StrangeIntegerBehavior.java

package CeShi;
public class StrangeIntegerBehavior {
 public static void main(String[] args)
 {
       
  Integer i1=100;
      
  Integer j1=100;
       
  System.out.println(i1==j1);
       
  Integer i2=129;
       
  Integer j2=129;
       
  System.out.println(i2==j2);
   
 }
}
 
 

 

 

 

 

 

动手动脑:

当创建一个对象时,它的构造方法会被自动调用。构造方法与类名相同,没有返回值。

如果类没有定义构造函数,Java编译器在编译时会自动给它提供一个没有参数的“默认构造方法”。

动手动脑

1、以下代码为何无法通过编译?哪儿出错了?

 

 

 

如果类提供了一个自定义的构造方法,将导致系统不再提供默认构造方法。

 

如果一个类中既有初始化块,又有构造方法,同时还设定了字段的初始值,谁说了算?

 

 

 

1、执行类成员定义时指定的默认值或类的初始化块,到底执行哪一个要看哪一个“排在前面”。

2、执行类的构造函数。。

类的初始化块不接收任何的参数,而且只要一创建类的对象,它们就会被执行。因此,适合于封装那些“对象创建时必须执行的代码”。

动手动脑2、

请运行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();

 

 

}

}

1、静态初始化块只执行一次。

2、创建子类型的对象时,也会导致父类型的静态初始化块的执行。

 

静态方法中只允许访问静态数据,那么,如何在静态方法中访问类的实例成员(即没有附加static关键字的字段或方法)?

package test.two;

 

public class jingtaihanshu

{

        int x = 3;

static int  y = 4;

public static void Method()//静态方法

     {  

           System.out.println("实例变量x = " + new jingtaihanshu().x);

           System.out.println("静态变量y = " + y);    

           }

         public static void void main(String[] args)

         {jingtaihanshu.Method();

              jingtaihanshuex = new jingtaihanshu();

                            System.out.println("x = " + ex.x);

         }            

}

posted @ 2019-10-17 22:24  Mr_WildFire  阅读(121)  评论(0编辑  收藏  举报