通过构造对象进行构造方法的调用,对应自己想调用的构造方法,看构造方法的参数个数进行传参.
上面main函数利用创建的对象person1调用的是无参构造方法
package lecture1;
class Person{
private String name;
private int age;
private static int count;
//构造方法 - 总是和类名相同,且无返回值
//当没有构造方法的时候,编译器会自动提供一个,不带参数的构造方法
//构造方法作用:实例化一个对象
//构造方法1:
public Person() {
//this("🐖🐖",1);
System.out.println("Person<init>");
//this("林🐖🐖");
}
//构造方法2:
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("Person<String,int>");
}
{
// this.name = "zhangfei";
// count = 99;
System.out.println("实例代码块......作用:访问普通成员变量");
}
static{
// this.name = "zhangfei";//牢记:静态不能访问非静态的数据成员
// count = 99;
System.out.println("静态代码块......");
}
public static void func() {
count = 99;
// this.name = "caocao";
}
//构造方法3:
public Person(String name) {
}
public void eat() {
System.out.println(this.getName());
System.out.println(this.age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
",age=" + age +
"}";
}
}
public class TestDemo {
public static void main(String[] args) {
Person person1 = new Person();
System.out.println("======================");
Person person2 = new Person();
}
运行结果
根上面代码的运行结果我们可以得到以下结论:
代码块打印顺序:
静态的方法 和 静态的 成员 不依赖对象.---我们可以通过类名进行访问.
如果静态方法里面访问 实例成员变量, 那么 这个实例成员变量是依赖对象的,但静态方法不依赖.
重要的事情说三遍:
静态里面不能有非静态数据成员!!!
静态里面不能有非静态数据成员!!!
静态里面不能有非静态数据成员!!!
package lecture1;
class Person{
private String name;
private int age;
public static int count;
static{
// this.name = "zhangfei";//牢记:静态不能访问非静态的数据成员
count = 99;
System.out.println("静态代码块......");
}
//构造方法 - 总是和类名相同,且无返回值
//当没有构造方法的时候,编译器会自动提供一个,不带参数的构造方法
//构造方法作用:实例化一个对象
//构造方法1:
public Person() {
//this("🐖🐖",1);
System.out.println("Person<init>");
//this("林🐖🐖");
}
//构造方法2:
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("Person<String,int>");
}
{
System.out.println("实例代码块......");
}
public static void func() {
count = 99;
// this.name = "caocao";
}
//构造方法3:
public Person(String name) {
}
public void eat() {
System.out.println(this.getName());
System.out.println(this.age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
",age=" + age +
"}";
}
}
public class TestDemo {
public static void main(String[] args) {
System.out.println(Person.count);
}
对比上面运行结果,左边打印出的count值为99,右边为0,我们可以得出: 如果代码块都是静态的, 那么打印结果 和定义的前后顺序有关
匿名对象就是没有名字的对象,每次使用只能使用一次
没有引用的对象称为匿名对象 匿名对象只能在创建对象时使用 如果一个对象只是用一次,后面不需要用了,可以考虑使用匿名对象
package lecture1;
class Person{
private String name;
private int age;
static{
// this.name = "zhangfei";//牢记:静态不能访问非静态的数据成员
count = 99;
System.out.println("静态代码块......");
}
public static int count = 0;
//构造方法 - 总是和类名相同,且无返回值
//当没有构造方法的时候,编译器会自动提供一个,不带参数的构造方法
//构造方法作用:实例化一个对象
//构造方法1:
public Person() {
System.out.println("Person<init>");
}
//构造方法2:
public Person(String name, int age) {
System.out.println("Person<String,int>");
}
//实例代码块
{
System.out.println("实例代码块......");
}
public static void func() {
count = 99;
// this.name = "caocao";
}
//构造方法3:
public Person(String name) {
}
public void eat() {
System.out.println(this.getName());
System.out.println(this.age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class TestDemo {
public static void main(String[] args) {
//有名对象↓
Person person1 = new Person();
person1.eat();
person1.eat();
System.out.println(person1.getName());
//匿名对象↓
new Person().eat();
new Person().getName();
}
📝总结: 一个类可以产生无数的对象,类就是模板,对象就是具体的实例。 类中定义的属性,大概分为几类: 类属性,对象属性。 其中被static所修饰的数据属性称为类属性,static修饰的方法称为类方法,特点是不依赖于对象,我们只需要通过类名就可以调用其属性或者方法。 静态代码块优先实例代码块执行,实例代码块优先构造函数执行。 this关键字代表的是当前对象的引用。并不是当前对象。