2--java面向对象语法学习（部分1-变量，重载，重写）

来源：互联网发布：博微配网设计软件编辑：程序博客网时间：2024/04/27 22:34

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

0 0