封装
封装概述
Java中封装的实质就是将类的状态信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。
封装反映课事物的相对独立性,有效避免了外部错误对此对象的影响,并且能对对象使用者由于大意产生的错误操作起到预防作用。同样面向对象编程提倡对象之间实现松耦合关系。
封装的好处在于隐藏类的实现细节,让使用者只能通过程序员规定的方法来访问数据,可以方便地加入存取控制修饰符,来限制不合理操作。
松耦合就是指尽量减少对象之间的关联性,以降低它们之间的复杂性和依赖性。
封装的步骤
修改属性的可见性
将Person类中的属性由public修改为private即可。
示例一:
将Person类的属性私有化。
关键代码:
public class Person {
private String name;//姓名
private String gender;//性别
private int age;//年龄
}
分析:
将public修改为private后,其他类就无法访问了,如果访问则需要进行封装的第二步。
设置setter/getter()方法
可以手动添加setter/getter()方法,也可以使用组合键Ctrl+Shift+S由系统添加。
示例二:
为Person类中的私有属性添加setter/getter()方法。
关键代码:
public class Person {
private String name;//姓名
private String gender;//性别
private int age;//年龄
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
设置属性的存取限制
此时,还没有对属性值设置合法性检查,需要在setter方法中进一步利用条件判断语句进行赋值限制。
示例三:
为setter方法设置限制:
关键代码:
public class Person {
private String name;//姓名
private String gender;//性别
private int age;//年龄
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
if(gender.equals("男")||gender.equals("女")){
this.gender = gender;
}else {
System.out.println("***性别不合法!***");
}
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age<0|age>150){
System.out.println("***输入的年龄为:" + age + ",该年龄不合法,将重置!***");
return;
}
this.age = age;
}
//构造方法
public Person(){
this.name="无名氏";
this.gender="男";
this.age=18;
}
public Person(String name,String gender,int age){
this.name=name;
this.gender=gender;
this.age=age;
}//方法:自我介绍
public void say(){
System.out.println("自我介绍一下,姓名:" + this.name + ",性别:" + this.gender + ",年龄:" + this.age + "岁。");
}
//以上为Person类定义代码,以下为调用代码
public static void main(String[] args) {
Person hanbing=new Person();
hanbing.setName("韩冰");
hanbing.setGender("女");
hanbing.setAge(221);
hanbing.say();
}
}
输出结果:
通过在setter方法中设置限制,避免了性别和年龄的误操作输入问题,这就是一个封装的典型实例。
示例四:
public class Dog {
//private私有化,保护属性不能篡改
private String name;
private int health;
private int love;
private String strain;
//访问的接口
public void setName(String name){//setter
this.name=name;
}
public String getName(){//getter
return this.name;
}
public void setHealth(int health){
//health的正常范围0-100
if(health<0||health>100){
System.out.println("健康值的范围在0-100之间");
System.out.println("赋的值不满足,强行默认值60");
health=60;
// this.health=60;
// return;
}
this.health=health;
}public int getHealth(){
return this.health;
}public void setLove(int love){
if(love<0||love>100){
System.out.println("亲密度的范围要在0-100");
System.out.println("赋的值不满足,强行默认值100");
love=60;
}this.love=love;
}public int getLove(){
return this.love;
}public void setStrain(String strain){
this.strain=strain;
}public String getStrain(){
return this.strain;
}
}
public class TestDog {
public static void main(String[] args) {
Dog d=new Dog();
d.setName("阿黄");
String str=d.getName();
System.out.println(str);
d.setHealth(-100);
System.out.println(d.getHealth());
d.setLove(50);
System.out.println(d.getLove());
d.setStrain("柯基");
String di=d.getStrain();
System.out.println(di);
}
}
输出结果:
总结
封装:
保护属性
开一个出口以供使用
包的概述
Java中的包机制也是封装的一种。
包主要有以下3个方面:
包允许将类组合成较小的单元(类似文件夹),易于找到和使用相应的类文件。
防止命名冲突:Java中只有在不同包中的类才能重名。不同的程序员命名同名的类在所难免。有了包,类名就容易管理了。A定义了一个类Sort,封装在包A中,B定义一个类Sort,封装在包B中。在使用时,为了区别A和B分别定义的Sort类,可以通过包名区分开,如A.Sort何B.Sort分别对应于A和B定义的Sort类。
包允许在更广的范围内保护类、数据和方法。根据访问规则,包外的代码有可能不能访问该类。
包的定义
定义包的语法格式如下:
packa包名;
package是关键字。
包的声明必须是Java源文件中的第一条非注释性语句,而且一个源文件只能有一个包声明语句,设计的包需要与文件系统结构相对应。因此,在命名包时,要遵守一下编码规范:
一个唯一的包名前缀通常是全部小写的ASCII字母,不能以圆点开头或结尾并且是一个顶级域名com、edu、gov、net及org,通常使用组织的网络域名的逆序。
包名的后续部分依不同机构各自部门的规范不同而不同。
包的使用
为了使用不在同一包中的类,需要在Java程序中使用import关键字导入这个类。
import 包名. 类名;
import java.util.*; //导入java.util包中所有类
import cn.jtest.classandobject.School; //导入指定包中指定类
注意事项:
一个类同时引用了两个来自不同包的同名类。
必须通过完整类名来区分。
每个包都是独立的,顶层包不会包含子包的类。
package和import的顺序是固定的。
package必须位于第一行(忽略注释行)。
只允许有一个package语句。
其次是import。
接着是类的声明。
类和类成员的访问控制
包实际上是一种访问控制机制,通过包来限制和制约类之间的访问关系。访问修饰符也同样可以限制和制约类之间的访问关系。
类的访问修饰符
Java中类的访问修饰符。
public修饰符:公有访问级别
默认修饰符:包级私有访问级别
类成员的访问修饰符
Java中类成员的访问修饰符。
总结
public:公共的;全工程可见
protected:子类继承的时候使用;包级私有+子类
默认:包级私有,当前类所在的包中可见
private:私用的;只用自己可见
static关键字
一个类可以创建n个对象 。如果n个对象中的某些数据需要共用,就需要使用static关键字修饰这些数据。
Java中,一般情况下调用类的成员都需要先创建类的对象,然后通过对象进行调用。使用static关键字可以实现通过类名加“.”直接调用类的成员,不需要创建类的对象。使用static修饰的属性和方法属于类,不属于具体的某个对象。
用static关键字修饰属性
用static修饰的属性称为静态变量或者类变量,没有使用static修饰的属性称为实例变量。
在实际开发中,用static关键字修饰属性的最常用场景就是定义使用final关键字修饰的常量。使用final关键字修饰的常量在整个程序运行时都不能被改变,和具体的对象没有关系,因此使用static修饰,如“static final int PERSON_LIVE=1;”。
注意:
常量名一般由大写字母组成。
声明变量时一定要赋初值。
用static关键字修饰方法
用static修饰的方法称为静态方法或者类方法,不用static关键字修饰的方法称为实例方法。
在静态方法中不能直接访问实例变量和实例方法。
在实例方法中可以直接调用类中定义的静态变量和静态方法。
实例五:
//演示static使用
public class TestStatic {
static{//静态代码块
//是在第一次访问该类时(在创建对象之前)执行,且只执行一次
//往往用来加载配置文件
System.out.println("静态代码块");
}
public TestStatic(){
System.out.println("无参构造");
}
public int a = 1;
public static int c=1;
public void test(){
a++;
c++;//普通方法可以看到静态属性
}
public static void abc(){
//静态方法中看不到普通属性和普通方法
c++;
}
public void def(){
abc();//普通方法可以直接调用静态方法
}
public static void main(String[] args) {
TestStatic ts1=new TestStatic();
ts1.test();
System.out.println(c);
System.out.println(ts1.a);
System.out.println();
TestStatic ts2=new TestStatic();
System.out.println(ts2.a);
}
}
输出结果:
示例六:
public class Test {
public static void main(String[] args) {
TestStatic ts1=new TestStatic();
ts1.test();
System.out.println(ts1.a);
System.out.println(TestStatic.c);
TestStatic.c++;
TestStatic.abc();//在不同类中,可以用类名.方法名()来调用静态方法
//往往用来做工具方法
}
}
输出结果:
示例七:模拟实现选民投票过程:一群选民进行投票,每个选民只允许投一次票,并且当投票总数达到100时,就停止投票
public class Voter {
public static int voteNum=0;
public static void vote(){
voteNum++;
}
}
public class TestVoter {
public static void main(String[] args) {
for (int i = 1; i <=200 ; i++) {
Voter.vote();
System.out.println("当前投票数为:"+Voter.voteNum);
if(Voter.voteNum==100){
System.out.println("投票完成");
break;
}
}
}
}
输出结果:
总结
static:
修饰属性是:全类共用一个存储空间
普通属性:一个对象用一个存储空间
修饰方法时:可以通过类型.方法名()调用
普通方法可以直接调用静态方法和普通方法
静态方法不能直接调用普通方法
普通方法可以直接调用普通属性和静态属性
静态方法不能直接调用普通属性
静态代码块:指在第一次访问该类时执行一次,且只执行这一次
静态变量必须是成员变量