面向对象——三大特性之——封装

 大纲：

1.  封装；

2. 构造函数；

3. this 关键字

封装性，面向对象的三大特点之一！

   【封装】——Encapsulation

         隐藏对象的属性和实现细节，仅对外提供公共访问方式。

【好处；】 

1. 将变化隔离； 

2. 便于使用；

3. 提高复用性； 

4. 提高安全性；

【封装原则】

      1. 将不需要对外提供的内容都隐藏起来；

      2. 把属性都隐藏，提供公共方法对其访问。

【private 】——私有的数据只在本类中有效。其他程序创建对象是无法直接访问的。

【代码】——

class Person
{
	private int age;
	public void setAge(int a)
	{
		if(a > 0 && a < 100)
			age = a;
		else
			System.out.println("输入的年龄不合法！");
	}
	public int getAge()
	{
		return age;
	}
	public void speak()
	{
		System.out.println("age + " + age);
	}
}
class PersonDemo
{
	public static void main(String[] args)
	{
		Person p = new Person();
		p.setAge(20);
		p.speak();
		int c = p.getAge();
		System.out.println("age +++++++++++++++++++++++ " + c);	
	}
}

   解决：在本类中私有，但是为了便于其他类对其访问，可以对外提供一些公共的方法来完成。

【通常情况下：】——会将类中的成员变量私有化，为了避免属性直接被访问导致数据错误。

                         并对外提供了公共的访问方式，对该属性进行访问。

                          这样做的好处：可以对属性进行可控。

                          而对属性设置和访问的公共方法名称规范定义格式为：set属性（） ， get属性（）；

【私有】——仅仅是封装的 一种体现形式而已。*（函数就是一个最小的封装体）

【私有】——private 是一个关键字，权限修饰符，用于 修饰成员（成员变量 和成员函数），注意 一定是 ——>成员变量 成员函数。

/*

需求：造个类 猫，将其成员属性 私有，但对外提供设置的方法。

*/

class cat
{
       private int age;
       private String color;
       private String sex;
       public void setAge(int a)
       {
              if(a>0 && a<130)
                     age = a;
              else
                     System.out.println("您输入的数值不合法，请重新输入！");
       }
       public int getAge()
       {
              return age;     
       }
       public void setColor(String b)
       {
              color = b;
       }
       public String getColor()
       {
              return color;
       }
       public void setSex(String c)
       {
              sex = c;
       }
       public String getSex()
       {
              return sex;
       }
}
class fengZ1
{
       public static void main(String[] args)
       {
              cat c = new cat();
              c.setAge(50);
              c.setSex("woman");
              c.setColor("blue");
              System.out.println("age = " + c.getAge() + "sex = " +c.getSex() + "color = " + c.getColor());
       }
}

【构造函数】

【什么是构造函数】

              创建的每个对象都是一个实体，每个实体必须要进行初始化后才可以使用。实体的初始化是需要通过动作完成的。这个动作就是构造函数。

【构造函数】——

              特点：

              1.函数名 与类名相同

              2.不用定义返回值类型；

              3.没有具体的返回值；

【构造函数作用：】

                     给对象进行初始化。

【特点：】任何用class 定义的类中，都有一个默认的空参数的构造函数。用于给该类对象进行初始化。

              如果该类中指定了具体的构造函数，那么默认的构造函数就被覆盖掉，没有了。

【构造函数和 一般函数的不同：】

              1.书写格式上不同；

              2.运行上的不同。

                     构造函数，是在对象一旦创建就被调用了。而且只执行一次。

                     一般函数，是对象创建完成后，需要时再调用，可以调用多次。

                     一般函数不能调用构造函数。构造函数是初始化的，初始化结束后，构造函数就结束。

              3.构造函数里有 return 语句的，用于结束构造函数的初始化！

 

              当一个类中存在着多个构造函数时，他们的存在形态是重载。

【构造函数什么时候用：】

                     当描述事物时，该事物一旦存在就具备着一些属性和行为；

                     那么就将这些内容定义在构造函数中。

【类的终结函数】

 终结函数 finalize 方法：

a) 如果在类的层次结构中的类定义了 finalize 方法，子类finalize 方法的最后一个动作应该是 调用超类的 finalize 方法，以保证当垃圾回收器回收对象占据的内容时，对象的所有部分都能正常终止。

【代码体现】

class Person
{
	private int age;
	private String name;

	Person()
	{
		System.out.println("Person now : RUN !");
	}

	Person(String s)
	{
		name = s;
	}

	Person(String s , int a)
	{
		name = s;
		age = a;
	}
	public void setName(String n)
	{
		name = n;
	}
	public String getName()
	{
		return name;
	}
	public void speak()
	{
		System.out.println(name + ":" + age);
	}
}
class gouZ1 
{
	public static void main(String[] args) 
	{
		Person p = new Person("lisi");
		p.setName("lisisisi");
		p.setName("liswnagci ");
		p.speak();
		System.out.println(p.getName());
		Person p1 = new Person("wangwu" , 29);
		p1.speak();
		Person p2 = new Person();
	}
}

【this】

【this关键字】

                     当成员变量和 局部变量同名的时候，为了区分，可以使用一个关键字来完成。

              this:代表的是一个对象；代表那个对象呢？那个对象调用this所在的函数，this就代表那个对象。

                     this就是当前对象的一个引用。

 

              this:

                     表现形式1 ：当局部变量和成员变量同名时，可以用this 来区分。

                     表现形式2 ：构造函数之间的调用可以使用this关键字，后面跟上小括号，指定具体的实参即可明确要调用的构造函数。

 

                     特殊情况：注意：调用本类中构造函数的this语句必须定义在构造函数的第一行。 因为初始化动作要先完成。

class Person
{
	private String name;
	private int age;

	Person()
	{
		System.out.println("Person now: RUN!");
	}
	Person(String name)
	{
		this();
		this.name = name;
	}
	Person(String name , int age)
	{
		this(name);
		this.name = name;
		this.age = age;
	}
	public void show()
	{
		this.speak();
	}
	public void speak()
	{
		System.out.println(this.name + "————" + this.age);
	}
}
class thisDemo3 
{
	public static void main(String[] args) 
	{
		//new Person();
		Person p1 = new Person("wangwu");
		Person p2 = new Person("wangcai" , 35);
		p1.show();
		p2.show();
		System.out.println("Hello World!");
	}
}

【this 什么时侯用：】

               当定义功能时，功能内部使用到了调用该功能的对象。这时就用this来表示。

需求：在Person类中定义一个比较方法，判断是否是同龄人。

/*

需求：在Person类中定义一个比较方法，判断是否是同龄儿。

思路：

       1.明确结果：boolean；

       2.明确未知内容：Person因为是一个任意一个Person对象比较其中的年龄；

*/

class Person
{
	private int age;
	private String name;

	Person(String name , int age)
	{
		this.name = name;
		this.age = age;
	}

	public boolean compare(Person p)
	{
		return this.age == p.age;
	}
}
class thisDemo1 
{
	public static void main(String[] args) 
	{
		Person p1 = new Person("wangwu" , 12);
		Person p2 = new Person("wangliu" , 45);

		boolean b = p1.compare(p2);
		System.out.println(b);
		System.out.println("Hello World!");
	}
}