//Constructor
package com.student.WeekThree;
import com.student.WeekTwo.Animals; //跨包调用要引入你想要调用的方法所在的类的地址(Animals类在student包里的WeekTwo包里)
public class Constructor001 {
public static void main(String[] args) {
PersonOne personone = new PersonOne("笨笨熊", 18);
PersonOne persontwo = new PersonOne("笨笨熊");
PersonOne personthree = new PersonOne(18);
Animals animal = new Animals(); //跨包调用
animal.bark();
System.out.println(personone.age + personone.name);
System.out.println(persontwo.name);
System.out.println(personthree.age);
//
DogTwo dogtwo = new DogTwo(); //这里调用的是DogTwo中的无参构造方法
DogThree dogthree = new DogThree("笨笨熊");//调用DogThree 类中的自己写的有参构造方法
DogFour dogfour = new DogFour();//当子啊类中自己定义了
DogFour dogfourf = new DogFour("笨笨熊",18);
}
} //如果我只是单纯定义了一个类,不在里面写任何构造方法,那么当我 DogTwo dogtwo = new DogTwo(); DogTwo()就是该类中的默认的构造方法
//DogTwo dogtwo = new DogTwo();正是调用了DogTwo类中的默认的构造方法
//如果我在该类中定义了一个有参构造方法,那么原先的默认的构造方法将会被覆盖,只能调用有参数的方法,如果我想再调用这个默认的构造方法
//那么我需要对它进行显示定义 即在类里写一个无参构造方法
//我在该类中将默认的无参构造方法显示定义,并更改方法体
//显示定义默认的无参构造方法并且更改方法体,那么我在调用它时 它会执行方法体里面的语句
class PersonOne{
String name;
int age;
//第一个构造器
public PersonOne(String pName, int pAge){ //构造器的作用:完成对象属性的初始化
System.out.println("构造器被调用");
name = pName;
age = pAge;
}
//第二个构造器
public PersonOne(String pName){ //构造器的作用:完成对象属性的初始化
System.out.println("构造器被调用");
name = pName;
}
//第三个构造器
public PersonOne(int pAge){ //构造器的作用:完成对象属性的初始化
System.out.println("构造器被调用");
age = pAge;
}
}
class DogTwo{
//编译器会自动提供一个默认的无参构造器。这个构造器什么都不做,只是简单地返回一个新创建的对象
}
class DogThree{
public DogThree(String name){
System.out.println("我是" + name);
}
}
class DogFour{
public DogFour(){
System.out.println("我是一头蠢熊");
}
public DogFour(String name,int age){
System.out.println("我是" + name + "今年" + age + "岁");
}
}
//ConstructorExercise
package com.student.Exercise;
public class ConductorExercise {
public static void main(String[] args){
Person person = new Person();
System.out.println(person.age + " " + person.name);
person = new Person("泡泡",23);
System.out.println(person.age + " " + person.name);
}
}
class Person{
int age = 1;
String name = "?";
public Person(){
this.age = 18;
this.name = "笨笨熊";
}
public Person(String pName,int pAge){
// pName = name;
// pAge = age;
this.name = pName;
this.age = pAge;
}
}
//this
package com.student.WeekThree;
public class This {
public static void main(String[] args){
Rubbit rubbit = new Rubbit("小白兔",3,1);
System.out.println(rubbit.name + " " + rubbit.age);
rubbit = new Rubbit("小白兔",3);
System.out.println(rubbit.name + " " + rubbit.age);
rubbit = new Rubbit("小白兔",3,'A');
System.out.println(rubbit.name + " " + rubbit.age);
Pig pig = new Pig();
System.out.println(pig.name + " " + pig.age);
Egg egg = new Egg("笨笨熊的蛋",23);
System.out.println("egg的hashcode:" + egg.hashCode());
}
}
class Rubbit{
String name;
int age;
public Rubbit(String rName,int rAge,int flag){
name = rName;
age = rAge;
}
public Rubbit(String name,int age){ //此时形参与属性同名,变量作用域遵循就近原则
name = name; //所以此时的name是传进来的参数name,age是传进来的参数age
age = age; //而新创建的对象rubbit的属性依旧为默认值
} //由此我们引入this
public Rubbit(String name,int age,char ch){ //这个this指的的是当前正在调用这个构造方法的对象,也就是第9h行的rubbit
this.name = name;
this.age = age; //this指的是正在调用这个构造器的对象
}//对比发现 this.age = age;和 egg.age = 18;结构十分相似
}//其实在堆中的对象中,有一个隐藏的this这this指向这个对象的地址
//那么此时我们打印this和egg的hashcode(不是地址,是地址对应的hashcode值)
//打印后我们发现二者的hashcode的值是相同的
class Pig{
String name;
int age; //访问构造器
//构造器1
public Pig(){ //在系统自动调用默认构造器1时,会执行构造器1中的语句
this("笨笨熊",18); //此时调用构造器2,并传入参数"笨笨熊" 18
}
public Pig(String name,int age){ //构造器2
this.name = name; //构造器2在 构造器1中被调用,相当于在Pig pig = new Pig();语句中间接调用了构造器2
this.age = age; //因此此时调用构造器2的对象为pig,故this指的就是pig
}
}
class Egg{
String name;
int age;
public Egg(String name,int age){
this.name = name;
this.age = age;
System.out.println("this的hashcode:" + this.hashCode());
}
}
构造器 java
于 2024-03-22 22:04:11 首次发布