封装

1. 封装

1.1. Java面向对象三大特性

(1)封装

(2)继承

(3)多态

1.2. 什么是封装？

封装是把类中的属性私有化，并提供公共的方法来返回属性的值，如果想从外部修改这些属性，只能通过公共的方法，而无法直接访问属性。类中的属性被隐藏，所以封装也成为数据隐藏。

1.3. 封装的步骤

（1） 将属性私有化

（2） 编写get和set方法（get,set访问器）

（3） 在get,set中根据需求可以加入属性控制语句

封装的好处：

l 类的属性可以对外只读。

l 类可以完全控制自己的属性。

l 类可以修改属性的数据类型，而不会影响到外部的调用。

示例：

public class Dog {

private String name; //名字

private int love;//和主人的亲密度 0-100

private int health;//健康值

private String strain; //品种

public String getName(){

return name;

}

public int getLove(){

return love;

}

public int getHealth(){

return health;

}

public String getStrain(){

return strain;

}

public void setName(String name){

this.name = name;

}

public void setLove(int love){

if(love>=0 && love<=100){

this.love = love;

}else{

System.out.println("亲密度输入有误，取默认值60");

this.love = 60;

}

}

public void setHealth(int health){

if(health>=0 && health<=100){

this.health = health;

}else{

System.out.println("健康值输入有误，取默认值60");

this.health = 60;

}

}

public void setStrain(String strain){

this.strain = strain;

}

/**

 * 显示宠物各项信息

 */

public void print(){

System.out.println("宠物的自白：\n我叫"+this.getName()+",我的健康为："+this.getHealth()

+",和主人的亲密度为："+this.getLove()+",我是一只"+this.getStrain());

}

}

package com.njwb.fengzhuang;

public class Dog2 {

private String name; //名字

private int love;//和主人的亲密度 0-100

private int health;//健康值

private String strain; //品种

public String getName(){

return name;

}

public int getLove(){

return love;

}

public int getHealth(){

return health;

}

public String getStrain(){

return strain;

}

public void setName(String name){

this.name = name;

}

public void setLove(int love){

if(love<0 || love>100){

System.out.println("亲密度输入有误，取默认值60");

this.love = 60;

return;

}

this.love = love;

}

public void setHealth(int health){

if(health<0 || health>100){

System.out.println("健康值输入有误，取默认值60");

this.health = 60;

return;

}

this.health = health;

}

public void setStrain(String strain){

this.strain = strain;

}

/**

 * 显示宠物各项信息

 */

public void print(){

System.out.println("宠物的自白：\n我叫"+this.getName()+",我的健康为："+this.getHealth()

+",和主人的亲密度为："+this.getLove()+",我是一只"+this.getStrain());

}

}

如何让类中的属性从外界只能写不能读？

场景：Person类实例化为小红时，不希望有getAge方法。

示例：略

总结：如果使用了封装，属性可以只读或者只写（不写get或set方法）。

如果类中的属性数据类型发生变化，如何把影响降到最低？

场景：age改为String类型。

示例：

private String age; //年龄

public String getAge(){

return this.age;

}

public void setAge(int age){

if(age>0 && age<=120){

this.age = String.valueOf(age);

}else{

System.out.println("年龄输入有误，将取默认值18");

this.age = String.valueOf(age);

}

}

总结：如果使用了封装，只需要稍微修改set方法。封装可以让我们更容易的修改内部代码却不会影响外部代码。

如何对成员变量进行精确的控制？

场景：设置年龄时打成了200岁

示例：

private int age;//年龄

public int getAge(){

return this.age;

}

public void setAge(int age){

if(age>0 && age<=120){

this.age = age;

}else{

System.out.println("年龄输入有误，将取默认值18");

this.age = 18;

}

}

总结：如果使用了封装，只需要稍微修改set方法。封装可以让类对赋值做出判断。

如何在取值时对返回结果精确控制？

场景：sex性别属性保存的值是0或1，但返回值要求男或女

示例：

/**

 * 传入的参数 是0或1，但是sex当前类的属性值是String类型

 * @param sexIndex

 */

public void setSex(int sexIndex){

if(sexIndex==0){

this.sex ="女";

}else if(sexIndex==1){

this.sex ="男";

}else{

System.out.println("性别输入有误，将取默认值男");

this.sex ="男";

}

}

1.4. 对象数组

package com.njwb.fengzhuang;

import java.text.DecimalFormat;

/**

 * 一个班有4个同学，每个同学有3门成绩，分别是语文成绩，数学成绩，英语成绩，设计一个方法，计算每个学生的平均分和总分

 * shift+alt+s ,按 r --> tab-->  enter--->shift tab -->enter

 * 右击---source---generater getter and setters ---select all--->ok 

 * 1.创建1个学生类 ，声明4个属性  名字 ，3门成绩

 * 2.创建1个业务类  声明1个方法，方法参数设计成对象数组

 * 3.测试类 ，准备好数据，存储对象数组 ，调用方法

 * @author Administrator

 *

 */

class Student{

private int chinese;//语文成绩

private int math;//数学成绩

private int english;//英语成绩

private String name; //学生名字

 

/**

 *无参构造

 */

public Student() {

}

/**

 * 带3个参数

 * @param chinese

 * @param math

 * @param english

 */

public Student(String name,int chinese,int math, int english) {

this.name = name;

this.chinese = chinese;

this.math = math;

this.english = english;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getChinese() {

return chinese;

}

public int getEnglish() {

return english;

}

public int getMath() {

return math;

}

public void setChinese(int chinese) {

this.chinese = chinese;

}

public void setEnglish(int english) {

this.english = english;

}

public void setMath(int math) {

this.math = math;

}

}

 

 

/**

 * 业务类，用来计数每个人的总分，均分

 * @author Administrator

 *

 */

class Calculate{

/**

 * 传的是对象数组 ,数组中的每一个元素都是学生对象stu ，每一个学生的总分，平均分

 * @param stus

 */

public void calScore(Student[] stus){

double sum = 0; //用来存储每一个学生的总分

for(int i=0;i<stus.length;i++){

sum = 0;//清零

Student stu = stus[i];

sum+= stu.getChinese()+stu.getMath()+stu.getEnglish();

//打印一个学生的平均分，总分

System.out.println(stu.getName()+"的总分为："+sum+",均分为："+new DecimalFormat("#.00").format(sum/3));

}

}

}

/**

 * 测试类

 * @author Administrator

 *

 */

public class TestScore {

public static void main(String[] args) {

/*//准备好数据 创建4个学生对象

Student stu1 = new Student("张三",78,90,98);

Student stu2 = new Student("李四",77,91,90);

Student stu3 = new Student("王五",75,92,93);

Student stu4 = new Student("赵六",73,93,97);

//声明长度为4的对象数组

Student[] arr = new Student[4];

//将准备好的数据，存入数组

arr[0] = stu1;

arr[1] = stu2;

arr[2] = stu3;

arr[3] = stu4;

//实例化业务类

Calculate ca = new Calculate();

//调用方法计算

ca.calScore(arr);*/

//声明长度为4的对象数组

Student[] arr = new Student[4];

//准备好数据 创建4个学生对象 存入数组

arr[0] = new Student("张三",78,90,98);

arr[1] = new Student("李四",77,91,90);

arr[2] = new Student("王五",75,92,93);

arr[3] = new Student("赵六",73,93,97);

//实例化业务类

Calculate ca = new Calculate();

//调用方法计算

ca.calScore(arr);

}

}

1.5. StringBuilder,StringBuffer

package com.njwb.stringuse;

/**

 * StringBuffer  线程安全的可变字符序列  ，效率低

 * StringBuilder 线程不安全的可变字符序列  两者的用法基本相同 ，效率高

 * StringBuffer()

          构造一个其中不带字符的字符串缓冲区，其初始容量为 16个字符。

    StringBuffer(int capacity)  capacity>0

          构造一个不带字符，但具有指定初始容量的字符串缓冲区。

    StringBuffer(String str)

          构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

"this_is_a_cat!"   1.改成“ThisIsACat!”  2.再改成“Cat!AIsThis”

"you is a good person!" 改成“YouIsAGoodPerson!” 改成“Person!GoodAIsYou”

先按“_”或者“ ”拆分成String[]数组 ，取出数组的每一个元素  ，每一个元素取出首字母转大写 ，每一个元素的其余字母不变，最后将每个元素拼接起来

 * @author Administrator

 *

 */

public class TestStringBuffer {

public static void main(String[] args) {

System.out.println("---------StringBuffer的使用--------------");

//StringBuffersb = new StringBuffer();

StringBuffer sb = new StringBuffer(10);

//有一个初始化的字符串

//StringBuffersb = new StringBuffer("today");

sb.append("hello").append("world").append("hello");

sb.append("hehe");

System.out.println(sb.toString());

System.out.println("---------StringBuilder的使用--------------");

//StringBuilder sb2 = new StringBuilder();

//StringBuilder sb2 = new StringBuilder(10);

StringBuilder sb2 = new StringBuilder("today");

sb2.append("today").append("is").append("cloudy");

sb2.append("hello");

System.out.println(sb2.toString());

}

}

package com.njwb.stringuse;

/**

 * "this_is_a_cat!"   1.改成“ThisIsACat!”  2.再改成“Cat!AIsThis”

 * @author Administrator

 *

 */

public class TestString {

public static void main(String[] args) {

String str = "this_is_a_cat!";

String[] arr = str.split("_");

System.out.println("--------方式1------------");

/*for(int i=0;i<arr.length;i++){

arr[i] =arr[i].substring(0, 1).toUpperCase()+arr[i].substring(1);

System.out.print(arr[i]);

}*/

//

/*for(int i=arr.length-1;i>=0;i--){

arr[i] =arr[i].substring(0, 1).toUpperCase()+arr[i].substring(1);

System.out.print(arr[i]);

}*/

System.out.println("--------方式2------------");

StringBuffer sb = new StringBuffer();

//索引

/*for(int i=0;i<arr.length;i++){

//拼接每个单词的首字母，首字母要大写 ，拼接每个单词的剩余字母

sb.append(arr[i].substring(0, 1).toUpperCase()).append(arr[i].substring(1));

}*/

for(int i=arr.length-1;i>=0;i--){

//拼接每个单词的首字母，首字母要大写 ，拼接每个单词的剩余字母

sb.append(arr[i].substring(0, 1).toUpperCase()).append(arr[i].substring(1));

}

System.out.println(sb.toString());

System.out.println("--------方式3------------");

StringBuffer sb2 = new StringBuffer();

//增强for  不可以逆序

for(String s:arr){

sb2.append(s.substring(0, 1).toUpperCase()).append(s.substring(1));

}

System.out.println(sb2.toString());

}

}

1.6. 作业

（1） 人机对话。实现以下对话：

用户：你好

电脑：你好，在啊？

用户：在啊

电脑：你在做什么？

用户：我在吃饭/我在听歌/我在睡觉/我在学习

电脑：饭好香/很好听/我也困了/加油哟~

用户：你会做什么？/你能做什么？/你有什么功能？/你的功能是什么？

电脑：我的特意功能就是什么都不会

用户：你喜欢吴彦祖、刘德华还是周星驰？你喜欢天空、沙漠还是大海？你喜欢女孩、人妖还是男孩？你喜欢房子、教室还是桌子？

电脑：我喜欢周星驰（随机）

用户：请告诉我120以内的奇数之和/请告诉我210以内的偶数之和

电脑：120以内的奇数之和是XXXX

用户：问：这个世界上谁最美？答：当然是XXX啦。

（把问题和答案存入数组questionListArray[0]=”问：这个世界上谁最美？答：当然是XXX啦。”）

电脑：嗯，记住啦。

用户：这个世界上谁最美？

电脑：当然是XXX啦。

用户：问：我的朋友谁最二？答：当然是王大锤啊！

电脑：嗯，记住啦。

用户：我的朋友谁最二？

电脑：当然是王大锤啊！

用户：拜拜

电脑：我走了

（2） 图书管理系统。应该正好是2个类，Demo.java+Book.java

=====图书管理系统=====

1. 显示所有的图书

2. 添加图书

3. 删除图书

4. 编辑图书

5. 购买

 

请输入功能编号（1~5）：

 

Book类

属性->数组BookList

Boolist[0] = “书名，价格，作者”;

 

构造方法

在构造方法中，初始化数组BookList，在没有添加图书时，至少内部有三本书。

 

第一个方法：showAllBook 显示所有数组中的图书

第二个方法：addBook 接收三个参数，分别是书名、价格、作者，存如数组

第三个方法：delBook删除图书，接收一个参数：书名，根据书名删除数组中的元素

第四个方法：editBook编辑图书，接收三个参数，分别是书名、价格、作者，根据书名修改价格和作者

第五个方法：buyBook购买图书，把所有图书显示出来，在左侧显示出图书的编号，

1 书名，价格，作者

2 书名，价格，作者

3 书名，价格，作者

4 书名，价格，作者

用户可以输入编号：1,2,3,4,表示想买哪种书，用户可以输入购买数量，

在控制台输出用户的购物清单，同时计算总价格。