Java学习_day08_（封装、this关键字、构造方法）

一. 封装（private)

封装：将一个事物的属性,私有化(对外进行隐藏),外界不能直接访问(保证了数据安全性),需要提供对外的
公共访问来访问成员变量!

private: 私有的,外界无法访问的,只能在本类中访问
特点：被private修饰的成员变量/成员方法，都只能在本类中访问，外界类不能直接访问，但可以通过公共方法间接访问

private 可修饰成员变量，也可以修饰成员方法，修饰的成员方法不能被重写

class Code{

	//成员变量
	int num = 20 ;
	
	//私有成员变量
	private int num2 = 30 ;
	
	//定义一个method方法:公共的
	public void method(){
		System.out.println(num) ;
		System.out.println(num2) ; //在本类中可以访问
	}
	
	//私有的成员方法
	private void function(){
		System.out.println("function code...") ;
	}
	
	public void show(){
		System.out.println("show code...");
		function() ;
	}
	
}



//测试类
class privateDemo{
	public static void main(String[] args){
		//要访问Code类中num和num2
		Code code = new Code() ;
		System.out.println(code.num) ;
		//System.out.println(code.num2) ;//num2 在 Code 中是 private 访问控制
		code.method() ;
		System.out.println("--------------") ;
		//code.function() ;// function() 在 Code 中是 private 访问控制
		code.show() ;
	}
}

需求：将昨天手机类:品牌(brand),价格(price),颜色(color),手机内存(memory). 行为:打电话,发短信
将属性全部私有化,提供对外的公共访问方法,测试!

//定义一个手机类
class Phone{
	//属性私有化
	private String brand ;//品牌
	private int price ; //价格
	private String color ;//颜色
	private int memory ; //手机内存
	
	//成员方法
	//setXXX(xxx xx)
	//给品牌赋值
	public void setBrand(String b){
		brand = b ;		
	}
	//给价格赋值
	public void setPrice(int p){
		price = p ;
	}
	
	//给颜色赋值
	public void setColor(String c){
		color = c ;
	}
	
	//给手机内存赋值
	public void setMemory(int m){
		memory = m ;
	}
	
	//获取品牌
	public String getBrand(){
		return brand ;
	}
	//获取价格
	public int getPrice(){
		return price ;
	}
	//获取颜色
	public String getColor(){
		return color ;
	}
	//获取手机内存
	public int getMemory(){
		return memory ;
	}
	
	//打电话,发短信
	public void callPhone(){
		System.out.println("手机可以打电话") ;
	}
	
	public void sendMessage(){
		System.out.println("手机可以发短信...") ;
	}
}


//手机类的测试类
class PhoneTest{

	public static void main(String[] args){
		//测试
		//创建一个手机类对象
		Phone p = new Phone() ;
		p.setBrand("华为 mate30") ;
		p.setPrice(4999) ;
		p.setColor("天空灰") ;
		p.setMemory(32) ;
		
		//获取内容
		System.out.println("手机的品牌是"+p.getBrand()+
		",价格式:"+p.getPrice()+",机身颜色是:"+p.getColor()+",它的内存大小为:"+p.getMemory()) ;
		p.callPhone();
		p.sendMessage() ;
	}

}

二. this关键字

this: 代表当前所在的类对象的地址值引用！
this作用：就是为了区分局部变量隐藏成员变量
this.成员变量：访问的是当前类的成员变量
this.成员方法名() ：访问的是当前类的成员方法
this(xx)/this()：访问的本类的有参构造方法/访问的本类的无参构造方法

需求:定义学生类
姓名,和年龄两个属性,属性私有化,提供公共访问方法赋值/获取值
吃,睡,学习,玩游戏

按照上面写完之后,
set方法赋值的时候,局部变量n,a:不能满足 (“标识符的规则”:见名知意)
将n,a---->name,age

给学生姓名赋值:
public void setName(String name) ;

name = name ;
}

局部变量和成员变量都叫name,如何区分呢? 这个时候Java提供了一个关键字:this
局部变量隐藏了成员变量,使用this关键字来区分

this:代表了当前类的对象的地址值的引用!

class Student{
	private String name ;
	private int age ;
	
	//setXXX(xxx)方法
	//public void setName(String n){
	public void setName(String name){
		//name = n ; 
		//name = name ;
		this.name = name ;  //区分了成员变量和局部变量
	}
	/*
	public void setAge(int a){
		age = a ;
	}
	*/
	public void setAge(int age){
		//age = age ;
		this.age = age ;
	}
	
	//getXXX()
	public String getName(){
		return name ;
	}
	
	public int getAge(){
		return age ;
	}
		
	
	//eat
	public void eat(){
		System.out.println("学习饿了,就需要吃饭...") ;
	}
	
	public void sleep(){
		System.out.println("学习困了,就需要休息") ;
	}
	
	public void study(){
		System.out.println("学习JavaEE...") ;
	}
}


//测试类
class StudentTest{
	public static void main(String[] args){
		//创建学生类对象
		Student s = new Student() ;
		s.setName("高圆圆") ;
		s.setAge(30) ;
		System.out.println(s.getName()+"---"+s.getAge()) ;
		s.eat() ; 
		s.sleep() ;
		s.study() ;
	}
}

三. 构造方法

什么是构造方法?
构造方法是一个方法,特殊的方法
1)方法名和类名一致!
2)没有具体返回值类型
3)连void都没有

格式: 权限修饰符(public:目前使用居多) + 类名(xx){}

构造方法的分类:
无参构造方法
有参构造方法
构造方法作用:

构造方法作用：就是为了 给类中的成员变量进行数据的初始化!(构造方法初始化!)

构造方法是可以重载的;

注意事项:
当前我们定义一个类的时候,没有提供任何构造方法,那么系统会默认无参构造方法;
但是,如果我们提供一个有参构造方法,系统不会在提供无参构造方法!(建议永远给出无参构造方法)

一个类的组成:
（1)成员变量
（2)加入构造方法：无参，有参构造方法
（3)成员方法

一个标准类的写法(正式写法)

需求:定义学生类
姓名,和年龄两个属性,属性私有化,提供公共访问方法赋值/获取值
吃,睡,学习,玩游戏

定义学生类,加入新的成员:构造方法
成员变量:属性私有化:name,age
构造方法:
无参构造/有参构造方法
成员方法:setXXX()/getXXX(),吃,睡,学习,玩游戏

给类的成员变量赋值有几种方式:
1)setXXX(xxx) :公共方法赋值
2)类的有参构造方法直接赋值;

改造手机类:加入新的成员:构造方法(Constructor)

class Student{

	//属性私有化
	private String name ; //姓名
	private int age ; //年龄
	
	//无参构造方法(永远给出)
	public Student(){
		
	}
	
	//有参构造方法
	public Student(String name,int age){//"张佳宁",30
		this.name = name ;
		this.age = age ;
	}
	
	//提供成员方法
	//setXXX()getXXX()
	public void setName(String name){
		this.name = name ;
	}
	public String getName(){
		return name ;  //隐藏 : return this.name ;  将this省略了
	}
	
	public void setAge(int age){
		this.age = age ;
	}
	
	public int getAge(){
		return age ;
	}
	
	//提供其他成员方法
	public String study(String className){
		return "正在学习"+className;
	}
	
	public void playGame(){
		System.out.println("学生可以玩游戏...") ;
	}	
}


//测试类
class Test{
	public static void main(String[] args){
		//方式1:无参构造方法+setXXX() +getXXX()
		Student s = new Student() ;
		s.setName("高圆圆") ;
		s.setAge(41) ;
		System.out.println("学生的姓名是"+s.getName()+",年龄是:"+s.getAge()) ;
		String result = s.study("JavaEE") ;
		System.out.println(result) ;
		s.playGame() ;
		
		System.out.println("----------------------------------") ;
		
		//方式2:有参构造方法+getXXX()
		Student s2 = new Student("张佳宁",30) ;
		System.out.println("学生的姓名是"+s2.getName()+",年龄是:"+s2.getAge()) ;
		String result2 = s2.study("Python") ;
		System.out.println(result2) ;
		s2.playGame() ;
	}
}

构造方法封装举例2：

//定义一个手机类
class Phone{
	//属性私有化
	private String brand ;
	private int price ;
	private String color ;
	private int memory ; 
	
	//无参构造方法
	public Phone(){}
	
	//有参构造方法
	public Phone(String brand,int price,String color,int memory){
		this.brand = brand ;
		this.price = price ;
		this.color = color ;
		this.memory = memory ;
	}
	
	//set方法
	public void setBrand(String brand){
		this.brand = brand ;
	}
	public String getBrand(){
		return brand ;
	}
	
	public void setPrice(int price){
		this.price = price ;
	}
	public int getPrice(){
		return price ;
	}
	
	public void setColor(String color){
		this.color = color ;
	}
	
	public String getColor(){
		return color ;
	}
	
	public void setMemory(int memory){
		this.memory = memory ;
	}
	
	public int getMemory(){
		return memory ;
	}
	
	public void callPhone(String callTo){
		System.out.println("可以给"+callTo+"打电话") ;
	}
	
	public void playGame(String gameName){
		System.out.println("可以玩"+gameName) ;
	}
}

//测试
class Test2{
	public static void main(String[] args){
		//方式1:无参+setxxx()/getxxx()
		Phone p = new Phone() ;
		p.setBrand("apple") ;
		p.setPrice(4599) ;
		p.setColor("土豪金") ;
		p.setMemory(16) ;
		
		System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor()+"---"+p.getMemory())  ;
		p.callPhone("高圆圆") ;
		p.playGame("王者农药") ;
		
		System.out.println("-------------") ;
		
		//方式2:有参构造+getxxx()
		Phone p2 = new Phone("华为",6799,"翡翠绿",32) ;
		System.out.println(p2.getBrand()+"---"+p2.getPrice()+"---"+p2.getColor()+"---"+p2.getMemory())  ;
		p2.callPhone("高圆圆") ;
		p2.playGame("王者农药") ;
		
	}
}