java面向对象封装_Java面向对象-封装

面向对象程序有以下特点：

封装性

继承性

多态性

封装

封装是面向对象编程的核心思想，将对象的属性和行为封装起来，其载体是类，第三方只需调用即可使用，无需关注内部的细节

继承

如有class A里面有一个add方法，现编写了一个class B 新增的class B可以使用extends 来继承class A并可直接使用class A中的add方法

多态

如创建了一个螺丝类，这个螺丝类中有两个属性：粗、细，然后又创建了两个类继承了螺丝类，他们两个都有各自的属性，长、短，综上所述，一个螺丝类衍生出不同的子类，子类继承父类特征的同时，也具备了自己的特征，并且能够实现不同的效果，这就是多态化结构。

Demo01PrintArray.java

import java.util.Arrays;

/*

* 面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。

* 面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。

*/

public class Demo01PrintArray {

public static void main(String[] args) {

int[] array = { 10, 20, 30, 40, 50, 60 };

// 要求打印格式为：[10, 20, 30, 40, 50]

// 使用面向过程，每一个步骤细节都要亲力亲为。

System.out.print("[");

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

if (i == array.length - 1) { // 如果是最后一个元素

System.out.println(array[i] + "]");

} else { // 如果不是最后一个元素

System.out.print(array[i] + ", ");

}

}

System.out.println("==============");

// 使用面向对象

// 找一个JDK给我们提供好的Arrays类，

// 其中有一个toString方法，直接就能把数组变成想要的格式的字符串

System.out.println(Arrays.toString(array));

}

}

类与对象

环顾周围，你会发现很多对象，比如桌子，椅子，同学，老师等。桌椅属于办公用品，师生都是人类。那么什么是 类呢？什么是对象呢？

什么是类?

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该 类事物。

现实中，描述一类事物：

属性：就是该事物的状态信息。

行为：就是该事物能够做什么。

举例：小猫。

属性：名字、体重、年龄、颜色。 行为：走、跑、叫。

什么是对象?

对象：是一类事物的具体体现。对象是类的一个实例(对象并不是找个女朋友)，必然具备该类事物的属性 和行为。

现实中，一类事物的一个实例：一只小猫。

举例：xxx家的那一只小猫。

属性：tom、5kg、2 years、yellow。 行为：溜墙根走、蹦跶的跑、喵喵叫

类与对象的关系

类是对一类事物的描述，是抽象的。

对象是一类事物的实例，是具体的。

类是对象的模板，对象是类的实体。

成员变量与成员对象的使用

* 成员变量赋值：

* A:setXxx()方法

* B:带参构造方法

学生类的使用，示例代码：

Student.java

/*

* 类的定义：

* 类是用来描述现实世界的事物的

*

* 事物：

* 属性事物的描述信息

* 行为事物能够做什么

*

* 类是如何和事物进行对应的呢?

* 类：

* 成员变量

* 成员方法

*

* 需求：写一个学生类

*

* 学生事物：

* 属性：姓名，年龄...

* 行为：学习，吃饭...

*

* 学生类：

* 成员变量(属性)：姓名,年龄

* 成员方法(行为)：学习,吃饭

*

* 成员变量(属性)：和我们前面学习过的变量的定义是一样的。

* 位置不同：类中，方法外

* 初始化值：不需要给初始化值

* 成员方法(行为)：和我们前面学习过的方法的定义是一样的。

* 需要去掉static关键字

*/

public class Student {

// 成员变量

// 姓名

String name;

// 年龄

int age;

// 成员方法

// 学习的方法

public void study() {

System.out.println("好好学习，天天向上");

}

//吃饭的方法

public void eat() {

System.out.println("学习饿了要吃饭");

}

}

StudentDemo.java

/*

* 通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。

*

* 1.导包：也就是指出需要使用的类，在什么位置。

* import 包名称.类名称;

* import cn.itcast.day06.demo01.Student;

* 对于和当前类属于同一个包的情况，可以省略导包语句不写；

* java.lang包下的类也可以省略不用import【一部分jdk官方自带的类在这下面】；

*

* 2.创建对象，格式：

* 类名称 对象名 = new 类名称();

* Student stu = new Student();

*

* 3.使用，分为两种情况：

* 使用成员变量：对象名.成员变量名

* 使用成员方法：对象名.成员方法名(参数)

* (也就是，想用谁，就用对象名点儿谁)

*

* 注意事项：

* 如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

*/

import Demo.Student; // 在同一个包下不进行导入也可以使用

public class StudentDemo {

public static void main(String[] args) {

// 格式：类名 对象名 = new 类名();

Student s = new Student(); // 在同一个包下面无需import就可使用到上面的Student类

// System.out.println("s:"+s); // com.itheima_02.Student@193c0cf

// 直接输出成员变量值

System.out.println("姓名："+s.name); // null

System.out.println("年龄："+s.age); // 0

System.out.println("----------");

// 给成员变量赋值

s.name = "张三";

s.age = 28;

// 再次输出成员变量的值

System.out.println("姓名："+s.name); // 张三

System.out.println("年龄："+s.age); // 28

System.out.println("----------");

// 调用成员方法

s.study();

s.eat();

}

}

eclipse执行结果：

姓名：null

年龄：0

----------

姓名：张三

年龄：28

----------

好好学习，天天向上

学习饿了要吃饭

一个常见的标准类

Student.java

package DemoCode;

/*

* 一个标准的类通常要拥有下面四个组成部分：

*

* 1. 所有的成员变量都要使用private关键字修饰

* 2. 为每一个成员变量编写一对儿Getter/Setter方法

* 3. 编写一个无参数的构造方法

* 4. 编写一个全参数的构造方法

*

* 这样标准的类也叫做Java Bean

*/

public class Student {

private String name; // private私有成员变量

private int age;

public Student(){ // 无参构造

}

public Student(String name, int age){ // 有参构造

this.name = name;

this.age = age;

}

public void setAge(int age) {

if (age < 0 || age > 1000) {

System.out.println("你给的年龄有误");

} else {

this.age = age;

}

}

public int getAge() {

return age;

}

public void setName(String name) {

this.name = name;

}

public String getName() {

return name;

}

public void show(){

System.out.println("当前name为：" + name + ", 当前age为：" + age);

}

}

StudentDemo.java

package DemoCode;

/*

* 学生类的测试类

*/

public class StudentDemo {

public static void main(String[] args) {

Student st = new Student("张三丰", 108);

System.out.println("当前name为：" + st.getName() + ", 当前age为：" + st.getAge());

System.out.println("===========华丽的分割线===========");

st.setAge(109);

st.show();

}

}

执行结果：

当前name为：张三丰, 当前age为：108

===========华丽的分割线===========

当前name为：张三丰, 当前age为：109

成员变量与局部变量的区别

public class Variable {

int x; // 成员变量

public void show() {

int y = 0; // 局部变量

System.out.println(x);

System.out.println(y);

}

}

private和public

/* 通过对象直接访问成员变量，会存在数据安全问题

* 这个时候，我们就想能不能不让外界的对象直接访问成员变量呢?

* 能。

* 如何实现呢?

* private关键字

*

* private:

* 是一个修饰符

* 可以修饰成员变量，也可以修饰成员方法

* 被private修饰的成员只能在本类中访问

*

* 针对private修饰的成员变量，我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰

*/

带有private关键字的变量和方法都只能在本类中直接使用，其他类不能直接使用这个私有方法，public其他类中可直接使用。

public：

public class sum {

public static void main(String[] args) {

get su = new get(); // 非静态方法需要先创建对象然后才能获取

su.add(1, 2);

}

}

class get{

public void add(int a, int b) { // void是无返回值得，如有返回值(return xxx)就写对应的类型如返回int就换成int，字符串就STring...

int num = a + b;

System.out.println("两个数相加的值为：" + num);

}

}

eclipse执行结果：

两个数相加的值为：3

private：

示例代码：

public class sum {

public static void main(String[] args) {

get su = new get(); // 非静态方法需要先创建对象然后才能获取

su.add(1, 2); // 这里就会出错

}

}

class get{

private void add(int a, int b) { // void是无返回值得，如有返回值(return xxx)就写对应的类型如返回int就换成int，字符串就STring...

int num = a + b;

System.out.println("两个数相加的值为：" + num);

}

}

eclipse执行结果：

报错：The method add(int, int) from the type get is not visible(这个类中的add方法不可见)

final关键字

一经声明在运行过程中不可重新赋值【后续有详细讲解】

final 类型 变量名称 = 值; // 建议全使用大写【注意：必须初始化一个值】

public class one {

public static void main(String[] args) {

final int A = 1;

A = 2; // 因A不可变所以这里会报错

}

}

this关键字

this:代表所在类的对象引用

方法被哪个对象调用，this就代表哪个对象

什么时候使用this呢？

局部变量和成员变量重名

Student.java

/*

* 学生类

*

* 起名字我们要求做到见名知意。

* 而我们现在的代码中的n和a就没有做到见名知意，所以我要改进。

*

* 如果有局部变量名和成员变量名相同，在局部使用的时候，采用的是就近的原则。

*

* 我们有没有办法把局部变量的name赋值给成员变量的name呢?

* 有。

*

* 什么办法呢?

* 用this关键字就可以解决这个问题

*

* this:代表所在类的对象引用

* 方法被哪个对象调用，this就代表那个对象

*

* 使用场景：

* 局部变量隐藏成员变量

*/

public class Student {

private String name; //成员变量

private int age;

public void setName(String name) { //"张三"

//name = name;

this.name = name; //将形参name赋值给成员变量name(this.name代表本类中的name)

}

public String getName() {

return name;

}

public void setAge(int age) {

//age = age;

this.age = age;

}

public int getAge() {

return age;

}

}

StudentDemo.java

/*

* 学生类的测试类

*/

public class StudentDemo {

public static void main(String[] args) {

//创建对象

Student s = new Student();

System.out.println(s.getName()+"---"+s.getAge());

s.setName("张三");

s.setAge(28);

System.out.println(s.getName()+"---"+s.getAge());

}

}

构造方法

/*

* 构造方法：

* 给对象的数据进行初始化

*

* 格式：

* 方法名和类名相同

* 没有返回值类型，连void都不能写

* 没有具体的返回值

*

*/

class Book{

public Book(){ //构造方法(类似Python里面的 def __init__(selef):)

}

...

}

构造方法没有返回类型，也不能定义为void

构造方法名称要与本类的名称相同

构造方法主要是作用是完成对象的初始化工作，它能把定义的对象参数传给对象成员

注意：构造方法分无参构造方法和有参构造方法，如果类中没有写构造方法编译器会默认创建一个无参构造方法

无参构造方法，示例代码：

public class BorrowAbook {

public BorrowAbook() {

}

public void borrow(String name) {

System.out.println("请前往借阅登记处领取:" + name + "。");

}

public static void main(String[] args) {

BorrowAbook book = new BorrowAbook();

book.borrow("《西游记》");

}

}

eclipse执行结果：

请前往借阅登记处领取:《西游记》。

有参构造方法，示例代码：

public class BorrowAbook {

String name; //成员变量

public BorrowAbook(String name) {

this.name = name; //将形参name赋值给成员变量name

}

public void borrow() {

System.out.println("请前往借阅登记处领取:" + name + "。");

}

public static void main(String[] args) {

BorrowAbook book = new BorrowAbook("《西游记》");//给构造方法传参

book.borrow(); //调用借书方法

}

}

eclipse执行结果：

请前往借阅登记处领取:《西游记》。

有默认值的有参构造方法：

public class EggCake {

int eggCount;

//创建一个有参构造方法

public EggCake(int eggCount) {

this.eggCount = eggCount;

System.out.println("这个鸡蛋里面有" + eggCount + "个蛋。");

}

//创建一个无参构造方法(如果没有上面的有参构造方法，下面的this(1)这种写法是会报错的)

public EggCake() {

this(1);

//this(1,xxx); //两个参数的情况

}

public static void main(String[] args) {

EggCake cake1 = new EggCake(); //调用无参构造方法(里面默认1个)

EggCake cake2 = new EggCake(5); //调用有参构造方法(需要传入一个数量)

}

}

eclipse执行结果：

这个鸡蛋里面有1个蛋。

这个鸡蛋里面有5个蛋。

**注意：**真正意义上其实不是有默认值得构造方法，只是创建了两个同名的构造方法(Java允许构造方法或普通方法同名【这就是方法重载】，只要接收形参不同就行)，一个可以接收参数一个默认赋值了一个参数而已。

使用两种方式给成员变量赋值：

Student.java

/*

* 学生类

*/

public class Student {

//成员变量

private String name;

private int age;

//构造方法

public Student() {}

public Student(String name,int age) {

this.name = name;

this.age = age;

}

//成员方法

public void setName(String name) {

this.name = name;

}

public String getName() {

return name;

}

public void setAge(int age) {

this.age = age;

}

public int getAge() {

return age;

}

}

StudentDemo .java

/*

* 学生类的测试类

*/

public class StudentDemo {

public static void main(String[] args) {

//无参+setXxx()

Student s = new Student();

s.setName("张三");

s.setAge(28);

System.out.println(s.getName()+"---"+s.getAge());

//带参构造方法进行传参

Student s2 = new Student("林青霞",28);

System.out.println(s2.getName()+"---"+s2.getAge());

}

}

end不再增加