class WashMachine{
public String brand; // 品牌
public String type; // 型号
public double weight; // 重量
public double length; // 长
public double width;// 宽
public double height; // 高
public String color; // 颜色
public void washClothes(){
System.out.println("洗衣服");
}
}
class PetDog{
public String name;
public String color;
public void bark(){
System.out.println("汪汪叫~~");
}
public void wag(){
System.out.println("摇尾巴~~");
}
}
public class Test {
public static void main(String[] args) {
PetDog dog1=new PetDog();//通过new实例化对象
dog1.name="阿黄";
dog1.color="黑黄";
System.out.println(dog1.name);
System.out.println(dog1.color);
dog1.bark();
dog1.wag();
}
}
class Data{
public int year;
public int month;
public int day;
public void setData(int y,int m,int d){
year=y;
month=m;
day=d;
}
public void show(){
System.out.println("年："+year+" 月："+month+" 日："+day);
}
}
public class Test {
public static void main(String[] args) {
Data data1=new Data();//新建一个对象
Data data2=new Data();
Data data3=new Data();
data1.setData(2024,1,30);//引用对象的函数赋值日期
data2.setData(2024,2,30);
data3.setData(2024,3,30);
data1.show();//引用对象的函数打印数据
data2.show();
data3.show();
}
现在看上面的代码似乎没有任何问题~
但我们仔细思考就会以下有两个问题：
1.但如果形参名与变量名相同怎么办呢？
public void setData(int year,int month,int day){
year=year;
month=month;
day=day;
}
class Data{
public int year;
public int month;
public int day;
public void setData(int year,int month,int day){
this.year=year;
this.month=month;
this.day=day;
}
public void show(){
System.out.println("年："+year+" 月："+month+" 日："+day);
}
}
注意：this引用的是调用该成员方法的对象
public static void main(String[] args) {
Date d = new Date();
d.setDay(2020,9,15);
d.printDate();
}
public class Date {
public int year;
public int month;
public int day;
// 构造方法：
// 名字与类名相同，没有返回值类型，设置为void也不行
// 一般情况下使用public修饰
// 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
public Date(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
System.out.println("Date(int,int,int)方法被调用了");
}
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
public static void main(String[] args) {
// 此处创建了一个Date类型的对象，并没有显式调用构造方法
Date d = new Date(2021,6,9); // 输出Date(int,int,int)方法被调用了
d.printDate(); // 2021-6-9
}
}
public class Date {
public int year;
public int month;
public int day;
// 无参构造方法
public Date(){
this.year = 1900;
this.month = 1;
this.day = 1;
}
// 带有三个参数的构造方法
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
public static void main(String[] args) {
Date d = new Date();
d.printDate();
}
}
上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载。
++5.如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。++
public class Date {
public int year;
public int month;
public int day;
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
public static void main(String[] args) {
Date d = new Date();
d.printDate();
}
}
上述Date类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。
注意：一旦用户定义，编译器则不再生成。
public class Date {
public int year;
public int month;
public int day;
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
public static void main(String[] args) {
// 如果编译器会生成，则生成的构造方法一定是无参的
// 则此处创建对象是可以通过编译的
// 但实际情况是：编译期报错
Date d = new Date();
d.printDate();
}
}
/*
Error:(26, 18) java: 无法将类 extend01.Date中的构造器 Date应用到给定类型;
需要: int,int,int
找到: 没有参数
原因: 实际参数列表和形式参数列表长度不同
*/
++6. 构造方法中，可以通过this调用其他构造方法来简化代码++
public class Date {
public int year;
public int month;
public int day;
// 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
// 但是this(1900,1,1);必须是构造方法中第一条语句
public Date(){
//System.out.println(year); 注释取消掉，编译会失败
this(1900, 1, 1);
//this.year = 1900;
//this.month = 1;
//this.day = 1;
}
// 带有三个参数的构造方法
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
}
注意：this(...)必须是构造方法中第一条语句并且不能形成环~
public Date(){
this(1900,1,1);
}
public Date(int year, int month, int day) {
this();
}
/*
无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用
*/
public class Date {
public int year;
public int month;
public int day;
public Date(int year, int month, int day) {
// 成员变量在定义时，并没有给初始值, 为什么就可以使用呢？
System.out.println(this.year);
System.out.println(this.month);
System.out.println(this.day);
}
public static void main(String[] args) {
// 此处a没有初始化，编译时报错：
// Error:(24, 28) java: 可能尚未初始化变量a
// int a;
// System.out.println(a);
Date d = new Date(2021,6,9);
}
}
要搞清楚这个过程，就需要知道 new 关键字背后所发生的一些事情：
Date d = new Date(2021,6,9);
在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单介绍下：
1. 检测对象对应的类是否加载了，如果没有加载则加载
2. 为对象分配内存空间
3. 处理并发安全问题
比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突
4. 初始化所分配的空间
即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值，比如：
5. 设置对象头信息(关于对象内存模型后面会介绍)
6. 调用构造方法，给对象中各个成员赋值
5.4 就地初始化
在声明成员变量时，就直接给出了初始值：
public class Date {
public int year = 1900;
public int month = 1;
public int day = 1;
public Date(){
}
public Date(int year, int month, int day) {
}
public static void main(String[] args) {
Date d1 = new Date(2021,6,9);
Date d2 = new Date();
}
}
