封装、包、访问权限修饰符、static变量

封装

        封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问，把尽可能多的东西藏起来，对外提供便捷的接口

        实现封装：

        1）修改属性的可见性：设为private，防止错误的修改

        2）创建共有的getter/setter方法：用于属性的读写

        3）在getter/setter方法中加入属性控制语句：对属性值的合法性进行判断

案例：

 

package demo02;
 
public class Penguin {
	// 定义属性
	private String name;
	private int health;
	private int love;
 
	public Penguin() {
 
	}
 
	public Penguin(String name, int health, int love) {
		this.name = name;
		this.health = health;
		this.love = love;
	}
	
	public void setName(String name){
		this.name=name;
	}
	
	public String getName(){
		return name;
	}
	
	public void setHealth(int health){
		//调用此方法来给对象的health赋值，在赋值前对传过来的health进行判断
		if(health<0||health>100){
			System.out.println("您输入的健康值有误，默认给健康值赋值为60");
			this.health = 60;
			return;//这里的return作用是结束方法后续代码的执行
		}
		this.health =health;
	}
	
	
	public int getHealth(){
		return health;
	}
	
	public void setLove(int love){
		//对传递过来的love值进行判断
		if(love<0||love>100){
			System.out.println("您输入的亲密度值有误，默认给亲密度赋值为80");
			this.love=80;
			return;
		}
		this.love=love;
	}
	
	public int getLove(){
		return love;
	}
	
 
	// 定义一个方法输出对象信息
	public void printInfo() {
		System.out.println("宠物信息：昵称：" + this.name + "，健康值：" + this.health
				+ "，亲密度：" + this.love);
	}
}

package demo02;
 
public class PenguinTest {
 
	public static void main(String[] args) {
		// 使用无参构造方法创建Penguin类的对象
		Penguin penguin1 = new Penguin();
		// 给对象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(-90);
		System.out.println(penguin1.getHealth());
		
		penguin1.setLove(-99);
		System.out.println(penguin1.getLove());
	}
 
}

 

封装的好处：

        便于使用者正确使用系统，防止错误修改属性；

        有助于系统之间的松耦合，提高系统独立性；

        提高软件的可重用性；

        降低了构建大型系统的风险； 

包（package）

包是Java语言有效地管理类的-一个机制。不同Java源文件中可能出现名字相同的类，如果想区分这些类,就需要使用包名。包名的目的是有效地区分名字相同的类,不同Java源文件中的两个类名字相同时，它们可以通过隶属于不同的包来相互区分。

通过关键字package声明包语句。package 语句作为Java 源文件的第一条语句， 指明该源文件定义的类所在的包，即为该源文件中声明的类指定包名。package 语句的一般格式为:

 package 包名;

包命名规范:

        包名由小写字母组成，不能以圆点开头或结尾;

package mypackage; 

        包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名;

package net.javagroup.mypackage; 

        包名后续部分依不同机构内部的规范不同而不同;

package net.javagroup.research.powerproject; 

包的作用：

        1）允许类组成较小的单元（类似 文件夹），易于找到和使用相 应的文件；

        2）防止命名冲突 区分名字相同的类；

        3）有助于实施访问权限控制 。

使用包的注意事项：

       1） 一个类同时引用了两个来自不同包的同名类 必须通过完整类名来区分；

 

//定义包
package cn.bdqn.demo03;
 
public class Test {
 
	public static void main(String[] args) {
		//创建Penguin类对象
		//如何使用不同包里面的同名类
		cn.bdqn.demo01.Penguin penguin1 = new cn.bdqn.demo01.Penguin();
		cn.bdqn.demo02.Penguin penguin2 = new cn.bdqn.demo02.Penguin();
		
		//java.lang包里面的类由系统自动导入，不需要写导包语句
		double num =Math.random();
 
	}
 
}

        2）每个包都是独立的，顶层包不会包含子包的类；

       3） package和import的顺序是固定的

        （1）package必须位于第一行（忽略注释行）

        （2）只允许有一个package语句

        （3）其次是import

        （4）接着是类的声明

访问权限修饰符

        所谓访问权限，是指对象是否可以通过“.”运算符操作自己的变量或通过“”运算符调用类中的方法。访问限制修饰符有private、protected、默认修饰符 和public，它们都是Java的关键字，用来修饰成员变量或方法。

        需要特别注意的是，在编写类的时候，类中的实例方法总是可以操作该类中的实例变量和类变量;类方法总是可以操作该类中的类变量，与访问限制符没有关系。

类的访问修饰

        类的访问修饰符

                public修饰符：公有访问级别

                默认修饰符：包级私有访问级别；被默认修饰符修饰的类只能被同一个包里的其它类访问

类成员的访问修饰

        用关键字private修饰的成员变量和方法称为私有变量和私有方法

        用public修饰的成员变量和方法被称为共有变量和共有方法

        不用private、 public、 protected 修饰符修饰的成员变量和方法被称为友好变量和友好方法

        用protected修饰的成员变量和方法被称为受保护的成员变量和受保护的方法

 

package cn.bdqn.demo07;
 
public class Student {
	//使用不同的权限修饰符定义属性
	public String name;
	protected int age;
	char gender;
	private double score;
	
	
	public static void main(String[] args) {
		//创建Student类对象
		Student stu = new Student();
		//给属性赋值
		//在同一个类中，被不同修饰符修饰的属性或者方法，对象都可以直接使用
		stu.name = "张三";
		stu.age = 22;
		stu.gender = '男';
		stu.score = 95;
	}
 
}

package cn.bdqn.demo07;
 
public class Test {
 
	public static void main(String[] args) {
		// 创建Student类对象
		Student stu = new Student();
		stu.name = "李四";
		stu.age = 23;
		stu.gender = '男';
		//被private修饰的属性或方法，只能在其所在的类里直接使用
//		stu.score = 100;
	}
 
}

package cn.bdqn.demo08;
 
import cn.bdqn.demo07.Student;
 
public class Test {
 
	public static void main(String[] args) {
		// 创建Student类对象
		Student stu = new Student();
		stu.name = "王五";
		//被protected修饰的属性或方法不能被不同包里的类直接访问
//		stu.age = 22;
		//默认修饰修饰的属性和方法不能被其它包里的类访问
//		stu.gender = '男';
		//被private修饰的属性和方法只能在本类中直接访问
//		stu.score = 99;
 
	}
 
}

static 

         static可以用来修饰

                成员变量

                        静态变量，可以直接通过类名访问

                成员方法

                        静态方法，可以直接通过类名访问

                代码块

                        静态代码块，当Java虚拟机加载类时，就会执行该代码块

        类的成员变量

                包括 类变量（静态变量）

                        被static修饰的变量

                        在内存中只有一个拷贝

                        类内部，可在任何方法内直接访问静态变量

                        其他类中，可以直接通过类名访问

package cn.bdqn.demo11;
 
public class StaticTest {
	//num是一个使用static修饰的成员变量，具有初始值0
	static int num;
 
	public static void main(String[] args) {
		num++;// num = 1
		StaticTest st1 = new StaticTest();
		st1.num++;//num=2
		StaticTest st2 = new StaticTest();
		st2.num++;//num=3
		StaticTest.num++;//num=4
		System.out.println(num);//4
	}
 
}

                实例变量

                        没有被static修饰的变量

                        每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响

package cn.bdqn.demo10;
 
public class Demo01 {
	
	//定义变量
	//没有使用static的变量称之为实例变量
	int num1 =100;
	
	//使用static修饰的变量称之为类变量/静态变量,静态变量可以直接使用类名来调用
	static int num2 =1000;
	
	public static void main(String[] args) {
		//实例变量只属于其所在的对象，各个对象之间不影响
		Demo01 d1= new Demo01();
		System.out.println(d1.num1);//100
		d1.num1 = 200;
		System.out.println(d1.num1);//200
		
		System.out.println(d1.num2);//1000
		d1.num2 = 2000;
		System.out.println(d1.num2);//2000
		
		Demo01 d2 = new Demo01();
		System.out.println(d2.num1);//100
		d2.num1 = 500;
		System.out.println(d2.num1);//500
		//使用static修饰的变量被对多个对象公用，一个对象对变量进行操作会影响另一个对象使用该数据
		System.out.println(d2.num2);//2000
		
	}
	
 
}

静态方法：可直接通过类名访问

        静态方法中不能使用this和super

        不能直接访问所属类的实例变量和实例方法

        可直接访问类的静态变量和静态方法

实例方法：通过实例访问        

        可直接访问所属类的静态变量、静态方法、实例变量和实例方法

静态方法必须被实现 main()就是最常用的静态方法