Java基础之面向对象封装性构造方法This关键字

一、封装性的概念
1、封装性是面向对象思想的三大特征之一。
2、封装就是隐藏实现细节，仅对外提供访问接口。
封装有：
属性的封装、方法的封装、类的封装、组件的封装、模块化封装、系统级封装…

二、封装的好处
1、模块化
2、信息隐藏
3、代码重用
4、插件化易于调试
5、具有安全性

封装缺点：
会影响执行效率

/**
	封装性
	如果属性没有封装，那么在本类之外创建对象后，可以直接访问属性
	private关键字：访问权限修饰符，public表示公有的，private表示私有的,私有的属性或方法，只能在本类中访问，
	公有的属性和方法，可以被类外部的其它类访问,想要在类外部访问私有属性，我们需要提供公有的方法来间接访问,
	通常在一个类中，属性都私有化，并对外提供getter and getter方法
*/
public class Test2{
	public static void main(String[] args){
		
		
		Person p1 = new Person();
		//p1.name = "菲菲";
		//p1.age = 18;
		p1.setName("菲菲");
		p1.setAge(18);
		
		
		p1.run(10);
		
		p1 = null;
		
	}
}

//没有封装之前
class Person{
	//属性的封装
	private String name; //成员变量，在类中定义
	private int age;  //成员变量，在类中定义
	
	//getter and setter
	
	//对外提供一个为name属性设值的方法
	public void setName(String name){
		this.name = name;
	}
	//对外提供一个获取name属性的方法
	public String getName(){
		return name;
	}
	
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
	
	public void run(int len){//参数也是局部变量
		int i;
		int m = len; // m也是局部变量
		System.out.println("我跑了"+m+"米");
		System.out.println(age);
	}
	
}

成员变量和局部变量 要理解

1、在类中的位置不同
成员变量：在类中定义
局部变量：在方法中定义或者方法的参数
2、在内存中的位置不同
成员变量：在堆内存(成员变量属于对象，对象进堆内存)
局部变量：在栈内存(局部变量属于方法，方法进栈内存)
3、生命周期不同
成员变量：随着对象的创建而存在，随着对象的销毁而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
4、初始化值不同
成员变量：有默认初始化值，引用类型默认为null
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用
注意：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

什么是构造方法

1、构造方法就是类构造对象时调用的方法，用于对象的初始化工 作

2、构造方法是实例化一个类的对象时，也就是new 的时候，最先调用的方法。

构造方法的定义：

构造方法是在类中定义的，构造方法的定义格式：方法名称与类名称相同，无返回值类型的声明。

对象的实例化语法：

Dog dog = new Dog(); //new Dog后面有个括号，带括号表示调用了方法，此时调用的方法就是构造方法了

/**
	构造方法:构造方法是在类中定义的，构造方法的定义格式：方法名称与类名称相同，无返回值类型的声明。
	1、构造方法就是类构造对象时调用的方法，用于对象的初始化工作
	2、构造方法是实例化一个类的对象时，也就是new 的时候，最先调用的方法。


*/
public class Test3{
	public static void main(String[] args){
		//Dog dog = new Dog();
		Dog dog1 = new Dog("wangwang",5);
	}
}

class Dog{
	
	//默认构造方法,通常有其它构造方法时，要保留默认构造方法
	//就是当有重载构造方法时 要把这个没有参数的没有输出的默认的构造方法写出来 不然没法new 
	public Dog(){
		//System.out.println("构造方法执行了");
	}
	public Dog(String name){
		this.name = name;
		System.out.println("带一个参数的构造方法执行了");
		
	}
	public Dog(String name,int age){
		this(name);//调用其它构造方法时，此语句需要在第一句,在构造方法相互调用时必须要有出口
		//就是不能你调用我 我调用你 就死循环了
		//this.name = name;
		this.age = age;
		System.out.println("带两个参数的构造方法执行了");
		
	}
	
	private String name;
	private int age;
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
}

构造方法重载：
无参构造方法：
public Dog(){}
带一个参数的构造方法：
public Dog(String name){
this.name = name;
}
带多个参数的构造方法：
public Dog(String name,int age){
this.name = name;
this.age = age;
}

（1）构造方法名称与类名相同，没有返回值声明（包括 void）
（2）构造方法用于初始化数据（属性）
（3）每一个类中都会有一个默认的无参的构造方法
（4）如果类中有显示的构造方法，那么默认构造方法将无效
（5）如果有显示的构造方法，还想保留默认构造 方法，需要显示的写出来。
（6）构造方法可以有多个，但参数不一样，称为构造方法的重载
（7）在构造方法中调用另一个构造方法，使用this(…)，该句代码必须在第一句。
（8）构造方法之间的调用，必须要有出口。
（9）给对象初始化数据可以使用构造方法或setter方法，通常情况下，两者都会保留。
（10）一个好的编程习惯是要保留默认的构造方法。（为了方便一些框架代码使用反射来创建对象）
（11）private Dog(){}，构造方法私有化，当我们的需求是为了 保正该类只有一个对象时。
什么时候一个类只需要一个对象？比如，工具类（没有属性的类，只有行为）并且该工具对象被频繁使用。权衡只用一个对象与产生多个对象的内存使用，来确定该类是否要定义为只需要一个对象。

This 关键字

在Java基础中，this关键字是一个最重要的概念。使用this关键字可以完成以下的操作：
· 调用类中的属性
· 调用类中的方法或构造方法
· 表示当前对象

/**
	this关键字
	调用类中的属性
· 	调用类中的方法或构造方法
· 	表示当前对象:在方法被调用的过程中，哪个对象调用了方法，在方法内的this就表示谁
this ： 谁调用了我 我就代表谁
	类名.this
*/
public class Test4{
	public static void main(String[] args){
		
		Cat cat = new Cat();
		cat.setName("咪咪");
		cat.setAge(3);
		
		cat.eat();
	}
}

class Cat{
	
	private String name;
	private int age;
	public void setName(String name){ //name=咪咪
		this.name = name; //this代表的是当前对象
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
	public void eat(){
		//在方法中使用this调用类中的其它方法或属性，this可以省略,this前面可以使用当前的类名.this
		//在后面的内部类知识点中会涉及到
		System.out.println("我是"+Cat.this.getName()+",我爱吃鱼");
		
		//System.out.println("我是"+this.name+",我爱吃鱼");
	}
}