java this构造函数_java-面向对象-封装-this-构造函数

class Person

{

//Person(){}

void Person(){}//这是一般函数。但不要这些书写，因为一般函数名称有规范。

}

main()

{

Person p = new Person();

}

*/

class Person

{

//属性：姓名，年龄。

private String name;

private int age;

//一初始化，既没有姓名，又没有年龄。

Person()

{

}

// Person(int a)

// {

// if(a<0)

// return;

// age = a;

// }

//定义构造函数，对象一创建就具备姓名。

Person(String n)

{

//将接收到的值赋值给对象的name

name = n;

}

//一初始化既有姓名，又有年龄。

Person(String n,int a)

{

name = n;

age = a;

}

//行为。

public void speak()

{

System.out.println("name="+name+",age="+age);

}

}

class PersonDemo2

{

public static void main(String[] args)

{

Person p1 = new Person();

// Person p = new Person("lisi");//对象创建时，必须会调用对应的构造函数，因为对象需要初始化。

// Person p2 = new Person("wangwu",23);

}

}

二 构造函数调用图解

三 基本数据引用数据类型参数传递图解

四 封装

表现：

1，函数就是一个最基本封装体。

2，类其实也是一个封装体。

从以上两点得出结论：

好处：

1，提高了代码的复用性。

2，隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。

3，提高了安全性。

它也是面向对象思想的特征之一。

共有三个特征：封装，继承，多态。

举例：机箱。隐藏了办卡设备的细节，对外提供了插口以及开关等访问内部细节的方式。

*/

//描述人。Person

//属性：年龄。

//行为：说话：说出自己的年龄。

/*

总结：

类中不需要对外提供的内容都私有化，包括属性和行为。

selectSort(int[] arr)

{

swap(

}

bubbleSort(int[] arr)

{

swap(

}

private swap(int[] arr,int a,int b)

{

}

重点：以后再描述事物，属性都私有化，并提供setXxx getXxx方法对其进行访问。

*/

class Person

{

//属性：

private int age;//age就是被修饰为了private私有。也就是被隐藏了。这就是封装的一种体现。

//行为：

void speak()

{

System.out.println("age="+age);

}

/*

年龄已被私有，错误的值无法赋值，可是正确的值也赋值不了，不行。

咋办，按照之前所学习的封装的原理，隐藏后，还需要提供访问方式。

通过方法的方式，让其他程序访问到，就可以了。更重要的是可以在方法中加入逻辑判断。

记住：对变量的访问操作有两个动作：赋值(设置 set)，取值(获取 get)

所以，对私有的变量访问的方式就是 set变量 get变量--> setAge getAge

*/

//定义对age赋值的方法。

void setAge(int a)

{

//加入逻辑判断。

if(a>0 && a<130)

age = a;

else

//System.out.println("对不起，您的年龄数值 "+a+" 是非法的。");

//throw new RuntimeException("对不起，您的年龄数值 "+a+" 是非法的。");//异常！一旦出现，程序结束。需要修正代码。

}

//定义一个获取age值的方法。

int getAge()

{

return age;

}

}

class PersonDemo

{

public static void main(String[] args)

{

//测试Person.class。

//创建对象。

Person p = new Person();

/*

赋值-20是可以的，因为age属性是int类型，但是确不符合现实生活中的事物。

怎么解决这个问题呢？

不让它访问就哦了。怎么在代码上实现呢？需要使用一个Java中的关键字也是一个修饰符 private(私有，权限修饰符)

记住：私有仅仅是封装的体现形式而已。

*/

//p.age = -20;//age不能在person类以外的程序中直接访问了。

//演示对age设置和获取方法的体现。

p.setAge(-20);

int a = p.getAge();

System.out.println("a="+a);

//p.speak();

}

}

五 this

5.1 当构造函数之间进行互相调用时，该如何解决呢？

构造函数是对象初始化时调用的。

给哪个对象初始化呢？通过this关键字来记录住对象的地址。并通过this来明确被初始化的对象。

在构造函数中调用其他构造函数的格式： this(实参列表);就会调用对应的构造函数。

小节：

this到底代表什么呢？★★★★★

this就代表对象，代表哪个对象呢？哪个对象调用了this所在函数，this就代表哪个对象。

*/

class Person

{

private String name;

private int age;

Person()

{

}

//初始化姓名。

private Person(String n)

{

name = n;

}

//初始化姓名和年龄。既然有初始化姓名的动作。直接调用就可以了。

Person(String n,int a)

{

this(n);//调用一个字符串参数的构造函数。注意：调用其他构造函数的语句，

//必须定义在构造函数的第一行。原因：初始化动作要先执行。

//name = n;

age = a;

}

}

class PersonDemo3

{

public static void main(String[] args)

{

Person p = new Person("lisi",20);

Person p1 = new Person("lisi1",21);

}

}

图解

/*

this关键字的另一个作用：

可以用this标识哪个变量是成员变量。这个标识可以省略不写。

但是，当局部变量和成员变量同名时，必须用this.来标识成员变量。

*/

class Person

{

private String name;

private int age;

Person(String name,int age)

{

this.name = name;

this.age = age;

}

public void speak()

{

String name = "haha";

System.out.println("name="+this.name+",age="+this.age);

}

public void method()

{

this.speak();//this可以省略。

}

5.2 练习

定义功能，判断两个人是否是同龄人。

//1,明确结果，boolean 2,明确未知内容，1个，Person类型。

public boolean equalsAge(Person pp)

{

/*

if(pp.age == this.age)//当函数中使用到了调用该函数的对象时，用this表示这个对象。

return true;

return false;

*/

//return (pp.age == this.age)?true:false;

return pp.age == this.age;

}

}

注意下面代码的结果

classPerson

{voidshow()

{

System.out.println(this);

}

}public classTest {public static voidmain(String[] args) {

Person p= newPerson();

p.show();

System.out.println(p);

}

}

结果