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

概要图

一 构造函数

需求：为了描述事物更准确，发现事物对应的很多对象一创建时，

就有了，一些初始化的数据。在类中该如何完成的。

 

通过Java中的另一个小技术完成：就是构造函数。对象本身就是构造出来，

构造时，需要做一些动作这些应该定义在函数内。

 

1.1 构造函数（Constructor）有什么用？

可以对对象创建进行初始化。

 

1.2 构造函数怎么在代码中体现呢？

1，没有返回值类型。因为构造对象，创建完就结束，需要结果。void也不要写，因为要有区别与一般函数。

2，构造函数名称和类名一致。

3，没有具体的返回值。

接下来，按照以上三点，在Person类中定义一个构造函数。

对象一创建就具备了姓名。

 

发现了问题？

没有学习构造函数时，对象也创建出来了。那么该对象是否有被构造呢？或者说是否有调用构造函数呢？

是的。必须调用！

那么类中那个构造函数是什么呢？

class Person
{
    //Person(){}//默认的空参数构造函数。
}

main()
{
    Person p = new Person();//这就已经调用了Person类中的空参数的构造函数。
                            //类中有定义该构造函数吗？有的。只要定义一个类，
                            //该类中默认就有一个空参数的构造函数，是编译器编译时添加到class文件中。
                            //注意：如果在类中自定义了构造函数，那么默认的空参数构造函数编译器就不添加了。
                            //原理：没有定义对象的初始化过程，编译器会添加一个默认的初始化过程。
                            //      如果定义了指定的对象初始化过程，默认的就不添加了。
}

1.3 构造函数的细节：

1，一个类中可以有多个构造函数，它们的存在是以重载的形式体现的。

2，构造函数中也是有return语句的，用于结束初始化动作的。

3，构造函数是否能被private修饰呢？能，作用：其他程序无法创建该类的对象。

class Person
{
    private Person(){}
}

main()
{
    Person p = new Person();//创建对象无法初始化。
}

1.4 构造函数和一般函数的区别？

1，写法不一样。不重要。

2，运行上有差别，对象一创建就会调用对应的构造函数。

    一般方法是对象创建后，才会调用所需的一般函数。

问：有了构造函数初始化姓名，那么还需要setName方法吗？

需要，因为对象创建后，如果需要对数据进行修改，可以通过set完成。

3，构造函数在对象创建时，仅调用一次(初始化动作只做一次，而且先执行)。一般方法可以被对象调用多次。

 

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;
}
}

　　

 注意下面代码的结果

class Person
{
    void show()
    {
        System.out.println(this);
    }
}
public class Test {

    public static void main(String[] args)  {
        Person p = new Person();
        p.show();
        System.out.println(p);

    }

}

结果