编程人 cdmana.com

java面向对象之封装

1.封装概念:

①将类的某些信息隐藏在类内部,不允许外部程序进行直接访问。

②通过该类提供的方法来实现对隐藏信息的操作和访问。

简单地说:隐藏对象的信息,留出访问的接口。

例子:钞票是ATM机的重要信息,我不能随意的去拿到里面的金钱,但是我可以通过银行卡,操作屏,取钞口等暴露出的接口获取金钱。

封装的特点:

1.只能通过规定的方法访问数据。

2.隐藏类的实例细节,方便修改和实现。

 

2. 封装的实现步骤:

①修改属性的可见性。设置为private私有化(只能在当前类内被访问,出了这个就不能被访问),通过这步实现信息的隐藏。

②设置开发接口:创建getter/setter方法(取值/赋值),设为public用于属性的读写。

③在getter/setter方法中加入属性控制语句。对属性值得合法性进行判断。(年龄需大于0等等)

 

3.代码实现:

第一步,修改属性为private

在测试类发现报错,可以证明类外不能直接访问private修饰的属性

cat类:

将代码修改为用private修饰,get set方法

package com.hoomsun.animal;

/**
 * 宠物猫类
 * 
 * @author dongwenjie
 *
 */
public class Cat {
	// 成员属性:昵称、年龄、体重、品种
	private String name;
	private int month;
	private double weight; 
	private String species;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getMonth() {
		return month;
	}

	public void setMonth(int month) {
		this.month = month;
	}

	public double getWeight() {
		return weight;
	}

	public void setWeight(double weight) {
		this.weight = weight;
	}

	public String getSpecies() {
		return species;
	}

	public void setSpecies(String species) {
		this.species = species;
	}

	public Cat() {
		System.out.println("我是无参构造方法");
	}

	public Cat(String name, int month, double weight, String species) {
		this();
		this.name=name;
		this.month =month;
		this.weight=weight;
		this.species=species;
	}

	// 成员方法:跑步、吃东西
	public void run() {
		String name;
		System.out.println("小猫快跑");
		System.out.println(this.name);
//		System.out.println(name);
	}

	public void eat() {
		System.out.println("小猫吃鱼");
	}
}

catTest类

package com.hoomsun.animal;

/**
 * 猫测试类
 * 
 * @author dongwenjie
 *
 */
public class CatTest {
	public static void main(String[] args) {
		// 对象猫实例化
		Cat one = new Cat();

		Cat two = new Cat();

		Cat three = new Cat("二笔呆", 16, 12.5, "英国短毛猫");
		
		// 测试方法
		one.eat(); // 小猫吃鱼
		one.run(); // 小猫快跑
		// 测试属性

		/*
		 * 对于一个类当中的成员属性而言,系统会默认给一个初始值的 字符串默认:null, double浮点数:0.0, int整型:0
		 */
		one.setName("小呆呆");
		one.setMonth(15);
		one.setWeight(8.6);
		one.setSpecies("狸花猫");

		two.setName("阿呆呆");
		two.setMonth(1);
		two.setWeight(2.6);
		two.setSpecies("花猫");
		System.out.println("名字:" + one.getName()); // 名字:小呆呆
		System.out.println("年龄:" + one.getMonth()); // 年龄:15
		System.out.println("体重:" + one.getWeight()); // 体重:8.6
		System.out.println("品种:" + one.getSpecies()); // 品种:狸花猫

		System.out.println("名字:" + two.getName()); // 名字:阿呆呆
		System.out.println("年龄:" + two.getMonth()); // 年龄:1
		System.out.println("体重:" + two.getWeight()); // 体重:2.6
		System.out.println("品种:" + two.getSpecies()); // 品种:花猫
		
		System.out.println("名字:" + three.getName()); // 名字:二笔呆
		System.out.println("年龄:" + three.getMonth()); // 年龄:16
		System.out.println("体重:" + three.getWeight()); // 体重:12.5
		System.out.println("品种:" + three.getSpecies()); // 品种:英国短毛猫

		System.out.println(one); // com.hoomsun.animal.Cat@7852e922
		System.out.println(two); // com.hoomsun.animal.Cat@4e25154f
		System.out.println(one == two); // false
		two = one;
		System.out.println(one);
		System.out.println(two);
		two = one;

	}
}

4.只有getxxx方法的属性是只读属性,只有setxxx方法的属性是只写属性。

5.通过异常处理的方式可以优化程序。

6.通过带参构造函数中调用set方法赋值是比较保险的。可以设置一些条件,比如年龄不能小于0等。

 

4.在Java当中如何进行不同类文件的管理呢?

通过包来进行文件的管理,解决同名文件冲突问题的。一个包里面不能建同名的类。(域名倒叙+模块+功能)

包引用必须放在类文件第一行。

建议每个包内存储信息功能单一

 

5.如何实现跨包的类调用,有几种调用形式?

全局引入和按需引入。

import com.hoomsun.animal.*;
import com.hoomsun.animal.Cat;

建议采取”import 包名.类名“的方式加载,提高效率。

加载类的顺序跟import导入语句的位置无关。

作用:①管理java文件 ②解决同名文件冲突。

定义包:package包名;例:package com.immoc.animal;

注意:必须放在java源文件中的第一行

一个java源文件中只能有一个package语句

包名全部英文小写

命名方式:域名倒叙+模块+功能。

 

 

 

6.static关键字。(静态信息)

首先猫类里面定义一个price属性

测试猫类里面去做赋值

    

给price加上static修饰符,会发现price变成了斜体。

然后测试类中报了一条警告,而且价格全变成了4000.

 

static:静态 静态成员  类成员  用static修饰的 无论这个类实例化出了多少对象,都会公用同一块存储空间。

对于普通的成员而言,当这个对象实例产生的时候,它的相关成员会产生。而对象销毁的时候,这些成员会进行自然释放。

静态成员则不然,当类第一次加载的时候就会产生,一直到这个类不再有任何对象被使用,也就是彻底销毁的时候,静态成员才会被彻底的释放。

特点总结:

①类对象共享 ②类加载时产生,销毁时释放,声明周期长。③既可以通过对象名访问,也可以通过类名访问。

static+属性===>静态属性/类属性

static+方法===>静态方法/类方法(也可以通过类名.方法名调用)

static不能加载类名前面否则会报错,类前面只能加 public abstract final三个关键字。

可以有静态属性 静态方法 不能有静态类

 

static也不能用于方法内的局部变量。

在成员方法当中,是可以直接访问类的静态成员的。反之,

在静态成员方法中不能访问非静态成员,如下报错了:(如果非要访问,需要先实例化一个对象,在调用)

 

 静态方法中也不能使用this,this代表实例,和static冲突。

 

7.代码块的概念

出现大括号对,就叫做代码块。在方法中定义时,就是普通代码块。

在类中定义构造代码块,会优先于构造方法执行,可以有多个构造代码块,按顺序执行。

加了static关键字就是静态代码块,静态代码块优先于构造代码块。

 

总结:

封装:①通过该类提供的方法来实现对隐藏信息的操作和访问。(隐藏对象的信息,留出访问接口)

封装的特点:①只能通过规定的方法访问数据。②隐藏类的实例细节,方便修改和实现。(我们只需要如何使用,并不需要深究它的内部实现构造)

封装的步骤:

 

包:作用:1.管理java文件。2。解决同名文件冲突。

定义包:package 包名;

注意:

 

导入包:

  

 

static属性:

 

 

 

 

 

Tags java atm
Scroll to Top