Java面向对象编程的三大特征之对象和封装
文章目录
-
- 一. 面向对象设计
-
- 1.1 什么是对象？
- 1.2 面向对象与面向过程
-
-
- 1.2.1 面向过程
- 1.2.2 面向对象
-
- 1.3 软件出现的目的
- 1.4 面向对象设计和开发程序
- 1.5 如何描述显示世界的对象
-
-
- 1.5.1 面向对象设计的过程就是抽象的过程，分三部来完成
- 1.5.2 以动物为例，我们如何在计算机中描述它们？
- 1.5.3 发现类
- 1.5.4 发现属性
- 1.5.5 发现方法
- 1.5.6 测试类
-
- 二. 类图
- 三. final修饰符
- 四. 构造方法及重载
- 五. static关键字
- 六. 面向对象三大特征之一 封装
-
- 6.1 封装的概念：
- 6.2 封装的好处：
- 6.3 封装的作用:
- 6.4 封装的步骤：
- 七. this关键字
一. 面向对象设计
1.1 什么是对象？
世界万物皆对象，世界是由对象组成的
1.2 面向对象与面向过程
举例：人把大象装进冰箱
//面向过程
1.打开冰箱
2.把大象装进冰箱
3.把冰箱门关注
//面向对象
人{
打开(冰箱){
冰箱.开门();
}
操作(大象){
大象.进入(冰箱);
}
关闭(冰箱){
冰箱.关门();
}
}
冰箱(){
开们(){
};
关门(){
};
}
大象(){
进入(冰箱){
};
}
1.2.1 面向过程
优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点：没有面向对象易维护、易复用、易扩展
1.2.2 面向对象
优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
缺点：性能比面向过程低
1.3 软件出现的目的
用计算机语言描述现实世界
用计算机解决现实中的问题
1.4 面向对象设计和开发程序
1.交流更加流畅
2.提高设计和开发效率
3.符合人类的思维习惯
4.提高设计和开发的效率
1.5 如何描述显示世界的对象
1.5.1 面向对象设计的过程就是抽象的过程，分三部来完成
- 发现类
- 发现类的属性
- 发现类的行为
1.5.2 以动物为例，我们如何在计算机中描述它们？
1.找出它们的种类
2.找出它们的属性
3.找出它们的行为
1.5.3 发现类
通过上面可以分为狗狗类和企鹅类
1.5.4 发现属性
1.5.5 发现方法
1.5.6 测试类
/**
* 狗狗类
*/
public class Dog {
String name="无名氏"; //昵称
int health = 100; //健康值
int love = 0; //亲密度
String strain = "聪明的拉布拉多"; //品种
/**
* 宠物自白
*/
public void print(){
System.out.println(String.format("宠物的自白:\n我的名字叫%s,健康值是%d,和主人的亲密度是%d,我是一只%s",this.name,this.health,this.love,this.strain));
}
}
/**
* 企鹅
*/
public class Penguin {
String name = "无名氏"; //昵称
int health = 100; //健康值
int love = 0; //亲密度
String sex = "Q仔"; //性别
/**
* 宠物自白
*/
public void print(){
System.out.println(String.format("宠物的自白：\n我的名字叫%s,健康值是%d,和主人的亲密度是:%d,性别是:%s",this.name,this.health,this.love,this.sex));
}
}
import java.util.Scanner;
/**
* 测试类
*/
public class Test {
public static void main(String[] args){
//创建扫描仪对象
Scanner input = new Scanner(System.in);
//输出基本信息
System.out.println("欢迎您来到宠物店！");
//输入领养宠物的姓名
System.out.print("请输入要领养宠物的名字:");
String name = input.next();
//输入领养储物的类别
System.out.print("请输入要领养的宠物类型(1.狗狗 2.企鹅):");
if(input.nextInt()==1){
//选择狗狗
System.out.print("请选择狗狗的品种(1.聪明的拉布拉多犬 2.酷酷的雪纳瑞):");
String strain = input.nextInt()==1 ? "聪明的拉布拉多犬":"酷酷的雪纳瑞";
//创建狗狗对象
Dog dog = new Dog();
dog.name=name;
dog.strain=strain;
dog.print();
}else{
//选择企鹅
System.out.print("请选择企鹅的性别(1.Q仔 2.Q妹):");
String sex = input.nextInt()==1? "Q仔":"Q妹";
//创建企鹅对象
Penguin pgn = new Penguin();
pgn.name=name;
pgn.sex=sex;
pgn.print();
}
}
}
二. 类图
用于分析和设计"类"，直观，容易理解
三. final修饰符
- final修饰变量，变量便常量
- final修饰方法，方法不能被重写
- final修饰类，类不能被继承
四. 构造方法及重载
构造方法:
- 方法名和类名相同，
- 与访问修饰符和返回值类型无关
- 分为有参构造和无参构造
- 作用:可以给声明的属性赋值
- 在没有声明构造方法的情况下，系统默认提供一个无参构造方法； 如果声明了构造方法，系统则不会提供默认的无参构造方法
方法重载:
- 在同一个类中
- 方法名相同
- 参数的列表不同{参数的个数不同,参数的顺序不同,参数的类型不同}
- 与访问修饰符和返回值类型无关
- 可以是普通方法构成，也可以是构造方法构成
/**
* 狗狗类
*/
public class Dog {
String name="无名氏"; //昵称
int health = 100; //健康值
int love = 0; //亲密度
String strain = "聪明的拉布拉多"; //品种
/**
* 无参构造
*/
public Dog(){
System.out.println("执行了无参构造");
}
/**
* 有参构造
* @param name 昵称
* @param strain 品种
*/
public Dog(String name,String strain){
System.out.println("执行了有参构造");
this.name=name;
this.strain=strain;
}
/**
* 全参构造
* @param name 昵称
* @param health 健康值
* @param love 亲密度
* @param strain 品种
*/
public Dog(String name,int health,int love,String strain){
System.out.println("执行了全参构造");
this.name=name;
this.health=health;
this.love=love;
this.strain=strain;
}
/**
* 宠物自白
*/
public void print(){
System.out.println(String.format("宠物的自白:\n我的名字叫%s,健康值是%d,和主人的亲密度是%d,我是一只%s",this.name,this.health,this.love,this.strain));
}
}
/**
* 测试类
*/
public class Test {
public static void main(String[] args){
//创建狗狗对象
Dog dog = new Dog(); //默认调用无参构造
dog.print();
System.out.println();
//调用有参构造
dog = new Dog("旺财","泰迪"); //调用有参构造
dog.print();
System.out.println();
//调用全参构造
dog = new Dog("黑虎",100,70,"金毛"); //调用全参构造
dog.print();
}
}
五. static关键字
static关键字修饰
- static可以修饰：变量，方法，代码块
- static修饰的变量可以使用类名直接调用
- static修饰的代码块自动加载，并且在第一行输出
public class StaticTest {
static int i;
static int m=30;
int j;
int k=25;
static{
i=10;
System.out.println(String.format("i的初始化值为:%d",i));
}
public StaticTest(){
j=20;
System.out.println(String.format("j的初始化值为:%d",j));
}
public static void getNum(){
System.out.println(String.format("得到i的值为:%d",i));
}
public static void main(String[] args){
StaticTest st = new StaticTest();
System.out.println("i的值为:"+StaticTest.i);
st.getNum();
System.out.println(String.format("m的值为:%d",st.m));
System.out.println(String.format("k的值为:%d",st.k));
}
}
从结果中可以得到以下结论
- 加载类的构成中,完成静态变量的内存分配，在执行静态块，两者是在创建对象之前完成的。
- 类属性和类方法可以通过类名和对象名访问，实例属性和实例方法只能通过对象名访问。
- 类方法只能访问类属性和其他类方法。
六. 面向对象三大特征之一 封装
6.1 封装的概念：
封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
6.2 封装的好处：
隐藏类的实现细节:让使用这只能通过程序规定的方法来访问数据；可以方便地加入存取控制语句，限制不合理操作。
6.3 封装的作用:
封装的作用是将代码中的细节全部私有化，不让别人看到，比如女孩子化妆，都是将自己最美的那一面展现出来，把不需要的物品(对象)隐藏。
6.4 封装的步骤：
public class Pet {
private String name; //姓名
//get和set方法就是封装
/**
* 读取姓名
* @return 姓名
*/
public String getName(){
return this.name;
}
/**
* 修改姓名
* @param name 姓名
*/
public void setName(String name){
this.name=name;
}
}
七. this关键字
this就是当前实例，this可省略，在局部变量和实例变量名称冲突时，可以用this.实例变量访问实例变量。当前实例就是指当前类本身
public class Pet {
private String name; //姓名
private int age; //年龄
private int health; //健康值
//使用this调用成员变量，解决成员变量和局部变量的同名冲突
public void setName(String name){
this.name=name; //成员变量和局部变量同名，必须使用this关键字
}
public void setAge(int nl){
age=nl; //成员变量和局部变量不同名,this可以省略
}
//使用this调用成员方法
public void play(){
this.print(); //调用方法
}
public void print(){
System.out.println("调用print方法");
}
//使用this抵用重载的构造方法，只能在构造方法中使用，必须是构造方法的第一条
public Pet(String name,int age){
this.name=name;
this.age=age;
}
public Pet(String name,int age,int health){
this(name,age); //调用重载的构造方法
this.health=health;
}
}
//调用属性
this.name=name;
//调用方法
this.print();
//调用构造方法 如果使用 必须写在构造方法的第一条语句
this(); //调用无参构造
this("孙",19); //调用有参构造