java 对象引用不等于null 怎么写

转载

码海探险先锋 2024-10-18 16:47:47

文章标签 面向对象函数 java 笔记 System 文章分类 Java 后端开发

1. 变量方法初始化顺序

字段（类的属性值） –> 构造函数 –> 方法（调用时加载）

不论变量放在哪儿都会先于任意一个方法的执行前执行，包括构造方法，而构造方法是一个类必须
会执行的方法，不需要显示的进行调用。同时，不论变量在哪儿分布，只要在方法外部，就一
定先于方法初始化。

**测试小案例：**

public class Person {

            public Person(int id) {
                System.out.println("person(" + id + ")");
            }

            public static void main(String[] args) {
                Build b = new Build();
            }
        }

        class Build {
            Person p1 = new Person(1);

            public Build() {
                System.out.println("this is build's block!");
                Person p2 = new Person(2);
            }

            Person p3 = new Person(3);
        }
    输出结果：
            person(1)
            person(3)
            this is build's block!
            person(2)

———- **2.初遇静态关键字static** ——————-

特点：

（1）只在装载时（装入.class文件后）初始化一次,
（2）外部对象引用：可以通类名直接访问

测试小案例：

public class Person {

        /*静态块*/
        static{
            System.out.println("this is static block!");
        }

        /*非静态块*/
        {
            System.out.println("this is non-static block!");
        }

        public Person(int id) {
            System.out.println("person(" + id + ")");
        }

        public static void main(String[] args) {
            Person p1 = new Person(1);
            Person p2 = new Person(2);
        }
    }
    输出结果：
    this is static block!
    this is non-static block!
    person(1)
    this is non-static block!
    person(2)

Java程序执行顺序

静态块 –> 构造方法 –> 静态属性 –> 非静态块属性 –> 构造器

1、先装载.class文件，创建Class对象，对静态数据（由static声明的）进行初始化，
而且只进行一次初始化。（如果有父类，先加载父类的静态快静态变量）
2、new Build()在堆上进行空间分配。创建时执行构造方法，先父后子
3、执行非静态块。
4、执行所有方法外定义的变量的初始化。
5、执行构造器
非静态方法不加载，使用时加载

父类静态 –> 子类静态 –> 父类构造方法 –> 子类构造方法

3.属性：

类中的属性一般分为类属性（全局变量）、实例属性（全局变量）、局部属性（局部变量）。(名称可以不一样，意思到就好)

类属性：
前面已经说过就是那些声明为static的属性，在整个过程中只进行一次初始化，在内存中只开辟一个空
间，不论在哪儿调用，值保持一致。一旦被修改，所有引用它的地方都会跟着修改。一般直接通过类名进行调用。

实例属性：
实例变量是可以不进行初始化，比如一个整型的实例变量假如没有初始化，则默认值为0；而局部变量
假如不赋初值语法上是通过的，但是在使用这个变量是程序就报错了。实例变量在堆和栈中都分配内存空间，在
堆当中分配的是对象本身，而栈中则是对这个对象的引用。

局部属性：
局部变量是在方法内部声明的变量，生命期仅在方法内，方法结束后变量就消失了；局部变量必须初始化再使用，
否则会报错,也就是说，假如你在方法内定义了一个局部变量，并且没有赋值，那么你在使用这个变量的时候一定
得赋值，不然就报错了。同时，局部变量可屏蔽全局变量。

4.重载：

指在同一个类中，具有相同的方法名，不同的参数列表的方法之间的一种机制。
参数列表的不同体现在：类型不同、个数不同、顺序不同，只要满足任一一个，就可以进行方法重载。

重载的好处：
增强了程序的可读性和易于维护，当有很多个功能相似的方法的时候，如果我们为每个方法设计一个名称，
想通过名称来区分它们的话，会很糟糕，而且会让人觉得程序的可读性差，设计不够巧妙

注意：试图通过返回值来进行方法重载是不正确的！会报错，，原因，无法确定该调用那个方法

5.重写：

重写是在继承中存在的，在两个类（子类和父类之间存在的关系）中，子类重写父类的方法，
方法名相同，参数也相同的一种机制。与重载类似，重写是写和父类相同方法名和相同参数的方法，对父类方法进行覆盖

public class B extends A {  

        public String a(String name) {  
        return "welcome to you :" + name;  
        }  
    }  
    class A {  
        public String a(String name){  
        return "hello:"+name;  
        }  
    }

6.类与对象的关系：

public class B {  

        public static void main(String[] args) {  
        B b = new B();  
        A a = new A();  
        }  
    }  

    class A {  

    }

1、类是一类具有相同属性的事物的统称，是一种抽象。
2、对象是类的具体体现，又称实例。
3、类是一种静态的概念，而对象是一种动态的机制。

测试用例：

package ObjectTest;

public class StrdyObject {

    public static void main(String[] args) {
//      Test2 test2 = new Test2("学习java");
//      test2.parents(10);
//      test2.parents(20);
//      System.out.println(Test2.intI);
//      System.out.println(test2.intI);

        Test2 test2 = new Test2();
        test2.studyRewrite(100,102);
        test2.studyIndefinite("ddd","mmm","kkl");
    }
}



/**
 * 
 * java程序执行顺序测试
 * @author 郑思林
 *
 */
class Parents{

    /*
     * java执行顺序测试
     * 
     */
//  static Parents parents = new Parents("父类中的Test2中字段实例化静态");
//  static{
//      System.out.println("父类中的static块中的内容");
//  }
//  static int i = 100;
//  
//  public final void parents(int t){
//      //int i = 100;
//      i = i + t;
//      System.out.println("静态成员方法   " + i);
//  }
//  
//  public Parents(String string) {
//      System.out.println(string);
//  }
//  
//  public Parents() {
//      System.out.println("parents中的构造方法");
//      //Test2 test2 = new Test2("新建对象");
//  }

    public void studyRewrite(int i){
        System.out.println(i);
    }

    public void studyRewrite(int i,int j){
        System.out.print(i + j);
    }
}

class Test2 extends Parents{

    /*
     * java执行顺序测试
     */
//  static int intI = 10;
//  static{     
//      System.out.println("子类中的static块中的内容");
//  }
//  
//  static Parents parents = new Parents("Test2中字段实例化静态");
//  Parents test1 = new Parents("Test2中字段实例化");
//  public Test2(String string) {
//      System.out.println(string);
//  }

    /*
     * 重写测试
     */
//  public void studyRewrite(int i,int t){
//      System.out.println(i+10);
//  }

    /*
     * 不定参数测试
     */

    public void studyIndefinite(String ...strings) {
        System.out.println(strings[1]);

    }
}


/*
 * final 和 abstract 只能用一个
 */
//final abstract class abstractClass{
//  
//}




/*
 * 执行顺序测试
 */

// class Person {  
//    
//    public Person(int id) {  
//        System.out.println("person(" + id + ")");  
//    }  
//}  

//public class StrdyObject {  
//     static 
//    /*静态块*/  
//   {  
//       int staticint = 100;
//        System.out.println("this is static block!");  
//    }  
//    /*非静态块*/  
//    {  
//        System.out.println("this is non-static block!");  
//    }  
//    Person p1 = new Person(1);//------------1-----------  
//  
//    public StrdyObject() {  
//        System.out.println("this is build's block!");  
//        Person p2 = new Person(2);  
//    }  
//  
//    Person p3 = new Person(3);  
//  
//    public static void main(String[] args) {  
//        StrdyObject b = new StrdyObject();  
//        
//    }  
//}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。