构造器，静态块
1、类和对象的关系
类是创建对象的模板。
对象是类的具体化。
2、如何创建类的对象呢？
构造器是创建对象的工具。
构造器是定义在类中，每一个类必须有构造器。
如果你在类中没有定义构造器，系统会提供一个缺省的无参构造器。
3、构造器的定义
语法：
[修饰符] 类名([参数]){
//方法体：对象属性的初始化代码
}
注意：构造器的名字必须和类名相同！！
构造器也叫构造方法，但不是方法。
构造器创建对象的，方法是解决问题的过程。
public class Student {
// 属性
public int number;
public String name;
public String sex;
public int score;
// 方法
public void display(){
System.out.println(number);
System.out.println(name);
System.out.println(sex);
System.out.println(score);
}
//构造器的定义
public Student(){
}
public Student(int num,String nm){
number=num;
name=nm;
}
public Student(int num,String nm,String s,int sr){
number=num;
name=nm;
sex=s;
score=sr;
}
}
4、调用构造器创建对象
类名 对象名=new 构造器名(实参);
执行过程：
/**
* 通过类名在方法区中找到这个类，（如果找不到，现加载类到方法区）
* 在堆中开辟对象空间，
* 将类中的属性和方法，赋予堆中的对象，
* 传参
* 执行方法体
* 返回对象的首地址
*/
5、构造器的重载
在同一个类中定义多个构造器的现象。
他们的参数必须不同，因为构造器的名字和类名必须相同。
构造器的方法体主要用于初始化创建的对象属性。
提供了多种初始化的方案。
十一、this关键字
1、第一种用法
同一个类的成员变量之间不能重名；
局部变量如果作用域有交集，不能重名；
成员变量和局部变量（参数）可以重名。
当参数或局部变量，和成员变量重名时，在方法体中直接访问的是参数或局部变量，成员变量被隐藏。
我们使用this.成员变量名来访问被隐藏的属性。
public class WuMingFen2 {
public String theMa;
public int quantity;
public boolean likeSoup;
public void setTheMa(String theMa){
this.theMa=theMa;
}
public WuMingFen2(String theMa,int quantity,boolean likeSoup){
this.theMa=theMa;
this.quantity=quantity;
this.likeSoup=likeSoup;
}
}
原因：this表示的是当前对象！！！
2、第二种用法
this当前类的构造器！！！
通过在一个构造器中调用另外一个构造器，从而减少构造器中重复代码的编写。
调用时，使用this(实参)；
public WuMingFen2(String theMa,int quantity,boolean likeSoup){
this.theMa=theMa;
this.quantity=quantity;
this.likeSoup=likeSoup;
}
public WuMingFen2(String theMa,int quantity){
// this.theMa=theMa;
// this.quantity=quantity;
// likeSoup=true;
//System.out.println();
this(theMa,quantity,true);
}
public WuMingFen2(){
// theMa="酸辣";
// quantity=2;
// likeSoup=true;
this("酸辣",2,true);
}
注意：this(..)语句必须时构造器方法体中的第一条语句。
十二、static关键字
1、static修饰符
static修饰的成员变量，我们叫静态变量，或者类变量。
static修饰的成员方法，我们叫静态方法，或者类方法。
没有使用static修饰的成员变量，我们叫实例变量。(实例=对象)
没有使用static修饰的成员方法，我们叫实例方法。
2、拥有关系
类变量和类方法属于类，实例变量和实例方法是属于对象。
类变量和类方法可以共享给所有对象。
使用类名访问类变量和类方法：类名.类变量 类名.类方法(..)
使用对象名访问实例变量和实例方法：对象名.实例变量 对象名.实例方法
使用对象名访问类变量和类方法：对象名.类变量 对象名.类方法
public class StaticDemo {
// 实例变量
public int a;
// 类变量
public static int b;
// 实例方法
public void test1(){
System.out.println(11);
}
// 类方法（静态方法）
public static void test2(){
System.out.println(22);
}
// 主方法：也是一个类方法（静态方法）
public static void main(String[] args) {
// 使用类名调用类变量和类方法
StaticDemo.b=22;
StaticDemo.test2();
// 使用对象名调用实例变量和实例方法
StaticDemo sd1=new StaticDemo();
sd1.a=11;
sd1.test1();
StaticDemo sd2=new StaticDemo();
sd2.a=12;
sd2.test1();
// 所有对象都可以调用类变量和类方法
sd1.b=23;
sd2.b=24;
sd1.test2();
sd2.test2();
System.out.println(StaticDemo.b);
}
}
3、类成员之间的访问
在实例方法中，可以直接访问所有成员（实例变量、类变量、实例方法、类方法）。
在类方法中，只能直接访问类变量和类方法；如果想要访问实例变量和方法必须指定是哪个对象的，先实例化。
public class StaticDemo {
// 实例变量
public int a;
// 类变量
public static int b;
// 实例方法
public void test1(){
System.out.println(11);
}
// 实例方法
public void test11(){
System.out.println(1111);
System.out.println(a);
System.out.println(b);
test1();
test2();
}
// 类方法（静态方法）
public static void test2(){
System.out.println(22);
}
// 类方法（静态方法）
public static void test22(){
System.out.println(2222);
// System.out.println(a);
System.out.println(b);
// test1();
test2();
// 如果想要访问实例变量和方法必须指定是哪个对象的，先实例化。
StaticDemo sd03=new StaticDemo();
System.out.println(sd03.a);
sd03.test1();
}
// 主方法：也是一个类方法（静态方法）
public static void main(String[] args) {
// 使用类名调用类变量和类方法
StaticDemo.b=22;
StaticDemo.test2();
// 使用对象名调用实例变量和实例方法
StaticDemo sd1=new StaticDemo();
sd1.a=11;
sd1.test1();
StaticDemo sd2=new StaticDemo();
sd2.a=12;
sd2.test1();
// 所有对象都可以调用类变量和类方法
sd1.b=23;
sd2.b=24;
sd1.test2();
sd2.test2();
System.out.println(StaticDemo.b);
// -------------------------------------------------
StaticDemo sd00=new StaticDemo();
sd00.test11();
StaticDemo sd01=new StaticDemo();
sd01.test11();
StaticDemo.test22();
}
}
4、静态块
new 构造器(..)
/**
* 通过类名到方法区找到类的信息（如果没有，加载类到方法区，执行静态块）
* 在堆里开辟对象的空间
* 将类的实例变量和实例方法赋予对象
* 执行初始化块
* 传参
* 执行方法体
* 返回对象首地址
*/
（1）初始化代码块（不用）
public class StaticDemo2 {
public int a=1;
public static int b=2;
public void test1(){
System.out.println(11);
}
public void test2(){
System.out.println(22);
}
// 初始化代码块
{
System.out.println("=="+a);
System.out.println("=="+b);
a=3;
b=4;
System.out.println("=="+a);
System.out.println("=="+b);
}
public StaticDemo2(){
System.out.println("--"+a);
System.out.println("--"+b);
a=5;
b=6;
System.out.println("--"+a);
System.out.println("--"+b);
}
public static void main(String[] args) {
// 实例化
new StaticDemo2();
}
new StaticDemo2();
执行流程：
加载类；
创建对象；
初始化属性；
初始化代码块；
构造器传参；
构造器的方法体；
返回对象。
（2）静态块（偶尔）
静态块有且仅在第一访问该类的时候执行一次，后面就不再执行。
静态块先执行！！！
new StaticDemo2();
执行流程：
加载类；
创建对象；
初始化属性；
静态块；
初始化代码块；
构造器传参；
构造器的方法体；
返回对象。
浙公网安备 33010602011771号