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