Java入门 面向对象(封装：导包、private修饰、static修饰、set\get方法)（第十七天）(一)

封装：

面向对象三大特征之一：封装

 封装的概念：

       将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是
        通过该类提供的方法来实现对隐藏信息的操作和访问

 封装的两个大致原则

        1）把尽可能多的东西藏起来，对外提供便捷的接口
         2）把所有的属性隐藏起来

如何实现封装：

    1、修改属性的可见性(将访问权限修饰符设为private，防止错误的修改)
    2、创建公有的get/set方法(用于属性的读写)
    3、在get/set方法中加入属性控制语句(对属性值的合法性进行判断)

封装的好处：

    1）便于使用者正确使用系统,防止错误修改属性
    2）有助于系统之间的松耦合,提高系统独立性
    3）提高软件的可重用性
    4）降低了构建大型系统的风险

代码：

 类

package Capsulation.demo;

public class Capsulation {

	//定义属性，使用private修饰符进行封装
	private String name;//名字
	private int health;//健康值
	private int love;//亲密度
	
	//无参构造方法
	public Capsulation(){
		
	}

	//有参构造方法
	public Capsulation(String name, int health, int love) {
		this.name = name;//姓名
		this.health = health;//健康值
		this.love = love;//亲密度
	}

	
	//set设置  get得到
	public String getName() {//姓名
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}

	//健康值
	public int getHealth() {
		return health;
	}

	public void setHealth(int health) {
		//调用此方法给health赋值，赋值前对传过来的health值进行判断
		if(health<0||health>100){
			System.out.println("输入健康值有误，默认健康值为：");
			this.health =60;
			return;//这里的return是结束方法后续代码的执行
		}
		this.health = health;
	}

	//亲密度
	public int getLove() {
		return love;
	}

	public void setLove(int love) {
		if(love<0||love>100){
			System.out.println("输入亲密度有误，默认亲密度为：");
			this.love =70;
			return;
		}
		this.love = love;
	}
	
	
	//定义方法输出对象信息
	public void printInfo(){
		System.out.println("宠物昵称："+this.name+" "+"健康值："+this.health+" "+"亲密度："+this.love);
	}

	
	
}

对象

package Capsulation.demo;

public class CapsulationTest {

	public static void main(String[] args) {

// 使用无参构造方法创建Capsulation类的对象
		Capsulation penguin1=new Capsulation();
		
		/*给对象penguin1的属性赋值，因为name属性使用private修饰了，
		所以不能同对象名.属性名直接给name属性赋值，只能是用其它方
		式给name属性赋值*/
//		penguin1.name = "QQ";
//		System.out.println(penguin1.name)

		
		/*penguin1.setName("QQ");//昵称
		String name = penguin1.getName();
		System.out.println(name);
		
		penguin1.setHealth(-20);//健康值
		System.out.println(penguin1.getHealth());
		
		penguin1.setLove(-10);//亲密度
		System.out.println(penguin1.getLove());*/
		
		

// 有参构造方法创建Capsulation类的对象
		//有参构造方法创建Capsulation类的对象
		Capsulation penguin2=new Capsulation("企鹅",20,30);
		//调用Capsulation类里的printInfo方法
		penguin2.printInfo();
		

	}

}

 导包：

为什么需要包

      包对应Java源文件的目录结构
        (package)包的作用：
        1）允许类组成较小的单元(类似文件夹)，易于找到和使用相应的文件
        2）防止命名冲突区分名字相同的类
        3）有助于实施访问权限控制

如何导包：

    import  包名.类名;
    import  包名.类名.*;//加星号就是导入该包里的所有类    

import java.util.Scanner.*;//加星号就是导入该包里的所有类	
import java.util.Scanner;

使用包的注意事项：

    一个类同时引用了两个来自不同包的同名类
            必须通过完整类名来区分
                  
   每个包都是独立的,顶层包不会包含子包的类
        
   package和import的顺序是固定的
            1）package必须位于第一行(忽略注释行)
            2）只允许有一个package语句
            3）其次是import
            4）接着是类的声明

package Capsulation.demo;

public class CapsulationTest {

	public static void main(String[] args) {
		//如何创建Dog类对象
		//如何使用不同包里面的同名类
		 Exercises.Dog dog1=new Exercises.Dog();
noCapsulation.demo.Dog dog2=new noCapsulation.demo.Dog();
		
        //java.lang包里面的类由系统自动导入，不需要写导包,直接去使用
        double num = Math.random();
		
	}
}
// 一个类同时引用了两个来自不同包的同名类
            必须通过完整类名来区分

注意：

  一个Java文件中只能有一个public修饰的类，并且这个类名要与Java文件名保持一致
  一个Java文件中可以有多个默认修饰符修饰的类
  建议一个Java文件中只写一个类

何使用不同包里面的同名类：

public class CapsulationTest {

	public static void main(String[] args) {
		//如何创建Dog类对象
		//如何使用不同包里面的同名类
		 Exercises.Dog dog1=new Exercises.Dog();
noCapsulation.demo.Dog dog2=new noCapsulation.demo.Dog();
		
        //java.lang包里面的类由系统自动导入，不需要写导包,直接去使用
        double num = Math.random();
		
	}
}

 访问权限控制：
    回顾
         属性隐藏
         包机制
    访问权限控制：
         类的访问控制
         类成员的访问控制