2--java面向对象语法学习（部分1-变量，重载，重写）
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)特点：
（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();
//
// }
//}