• 04-类与对象动手动脑问题及课后实验性问题总结


    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之类的变量;

    后者为“引用类型”变量,“引用”一个对象的变量称为“引用类型”的变量,有时又简称为“对象变量”。

    “引用”一个对象的变量称为“引用类型”的变量,有时又简称为“对象变量”。诸如int,float之类的变量称为“原始数据类型”的变量)。

    从变量与内存分配上讲,当声明一个对象类型的变量时,实际上并没有创建一个对象,此变量=null。定义一个原始类型的变量时,会马上给其分配内存。
    从变量的初始化上讲,在定义原始变量时,Java要求必须显式初始化变量;而对象变量的初始化:对象变量如果不引用一个真实的对象,则必须声明为null。
    而且引用对象后的对象变量,如果不再使用此变量,JVM会回收MyClass对象所占用的内存(垃圾回收)。

    3.对象判等:对于原始数据类型的变量(比如int),可以直接使用“==”判断两变量值是否相等,那么对象变量也可以使用“==”判断两变量值是否相等吗?

    public class ClassAndObjectTest {
    
        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.以下代码为何无法通过编译?哪儿出错了?

    如果类提供了一个自定义的构造方法,将导致系统不再提供默认构造方法。所以将“Foo obj1 = new Foo();”改为“Foo obj1 = new Foo(4);”来实现运行。

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

     

     在“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;}”之后:

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

    结论(静态初始化块的执行顺序):静态初始化块只执行一次。创建子类型的对象时,也会导致父类型的静态初始化块的执行。

     7.

    //静态方法中只允许访问静态数据,那么,如何在静态方法中访问类的实例成员(即没有附加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(){
     }
     }

  • 相关阅读:
    [Javascript] Broadcaster + Operator + Listener pattern -- 10. Define a Function to Set Common Behaviors in Operators
    [Java Spring] Aspect
    [Javascript] Broadcaster + Operator + Listener pattern -- 24. Design choice, ifElse or merge
    [Javascript] Broadcaster + Operator + Listener pattern -- 23. ifElse operator
    [Git] Revert to a old commit
    [Tools] Dendron
    [Java Spring] Spring Expression Language
    [Java Spring] @Profile
    [Java Spring] @Value & override properties by environment variables
    [Java Spring] Implementing Spring Security
  • 原文地址:https://www.cnblogs.com/zhangjiabei/p/5984859.html
Copyright © 2020-2023  润新知