第十二章 面向对象

于 2022-05-18 15:32:50 发布
阅读量323 收藏 1
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47049311/article/details/124843528
版权
本文介绍了面向对象编程的基础概念，如类和对象关系、创建对象、封装性、继承与多态，以及Java中如何定义和使用类实例。通过实例演示了如何创建Student和Phone类，并探讨了私有成员变量和getter/setter的使用。
摘要由CSDN通过智能技术生成

12.1 面向对象思想的概述

package cn.day06;
import java.util.Arrays;
/*
面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。
 */
public class Demo01PrintArray{
    public static void main(String[] args) {
        int[] array = { 10, 20, 30, 40, 50};
        //要求打印格式为：[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给我们提供好的Array类
        //其中有一个toString方法，直接就能把数组变成想要的格式的字符串
        System.out.println(Arrays.toString(array));
    }
}

面向对象的三大基本特性：封装、继承和多态

帮你做事的那个就是对象

12.2 类和对象的关系

类是一组相关属性（是什么）和行为（能做什么）的集合

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

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

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

package day06;
/*
定义一个类，用来模拟“学生”事物，其中就有两个组成部分：
属性（是什么）：姓名、年龄
行为（能做什么）：吃饭、睡觉、学习

对应到Java的类当中：
成员变量（属性）：
    String name;//姓名
    int age;//年龄
成员方法（行为）：
    public void eat() {} //吃饭
    public void sleep() {} //睡觉
    public void study() {} //学习

注意事项：
1.成员变量是直接定义在类当中的，在方法外边。
2.成员方法不要写static关键字。
 */
public class student {
    //成员变量
    String name; //姓名
    int age; //年龄

    //成员方法
    public void eat() {
        System.out.println("吃饭");;
    }

    public void sleep() {
        System.out.println("睡觉");;
    }

    public void study() {
        System.out.println("学习");;
    }
}

12.3 对象的创建及其使用

package day06;

import jdk.swing.interop.SwingInterOpUtils;

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

1.导包：也就是指出需要使用的类，在什么位置。
import 包名称.类名称;
import day06.Student;
对于和当前类属于同一个包的情况，可以省略导包语句不写。

2.创建，格式：
类名称 对象名 = new 类名称();
Student stu = new Student();

3.使用，分为两种情况：
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名（参数）
（也就是，想用谁，就用对象名点儿谁。）

注意事项：
如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样
 */
public class Demo02Student {
    public static void main(String[] args) {
        //1.导包
        //我需要使用的Student类，和我自己Demo02Student位于同一个包下，所以省略导包语句不写

        //2.创建，格式：
        //类名称 对象名 = new 类名称();
        //根据Student类，创建了一个名为stu的对象
        student stu = new student();

        //3.使用其中的成员变量，格式：
        //对象名.成员变量名
        System.out.println(stu.name);//null
        System.out.println(stu.age);//0
        System.out.println("=============");

        //改变对象当中的成员变量数值内容
        //将右侧的字符串，赋值给stu对象当中的name成员变量
        stu.name = "Anna";
        stu.age = 18;
        System.out.println(stu.name);//Anna
        System.out.println(stu.age);//18
        System.out.println("=============");

        //4.使用对象的成员方法，格式:
        //对象名.成员方法名（）
        stu.eat();
    }
}

12.4 手机类练习

package day06;
/*
定义一个类，用来模拟“手机”事物。
属性：品牌、价格、颜色
行为：打电话、发短信

对应到类当中：
成员变量（属性）：
    String brand;//品牌
    double price;//价格
    String color;//颜色
成员方法（行为）：
    public void call (String who){}//打电话
    public void sendMessage(){}//群发短信
 */
public class Phone {
    //成员变量
    String brand;//品牌
    double price;//价格
    String color;//颜色

    //成员方法
    public void call(String who){
        System.out.println("给" + who + "打电话");
    }

    public void sendMessage(){
        System.out.println("群发短信");
    }
    }
package day06;

public class Demo01PhoneOne {
    public static void main(String[] args) {
        //根据Phone类，创建一个名为one的对象
        //格式：类名称 对象名 = new 类名称 ();
        Phone one = new Phone();
        System.out.println(one.brand);//null
        System.out.println(one.price);//0.0
        System.out.println(one.color);//null
        System.out.println("=========");

        one.brand = "苹果";
        one.color = "黑色";
        one.price = 8388.0;
        System.out.println(one.color);//黑色
        System.out.println(one.price);//8388.0
        System.out.println(one.brand);//苹果
        System.out.println("=========");

        one.call("Anna");//给Anna打电话
        one.sendMessage();//群发短信
    }
}

12.5 一个对象的内存图

 12.6 两个对象使用同一个方法的内存图

 12.7 两个引用指向同一个对象的内存图

 12.8 使用对象类型作为方法的参数

12.9 使用对象类型作为方法的返回值 

12.10 成员变量和局部变量的区别

package demo03;
/*
 局部变量和成员变量
 1.定义的位置不一样【重点】
 	局部变量：在方法的内部
 	成员变量：在方法的外部，直接写在类当中
 2.作用范围不一样【重点】
 	局部变量：只有方法当中才可以使用，出了方法就不能再用
 	成员变量：整个类全都可以通用
 3.默认值不一样【重点】
 	局部变量：没有默认值，如果要想使用，必须手动进行赋值
 	成员变量：如果没有赋值，会有默认值，规则和数组一样
 4.内存位置不一样（了解）
 	局部变量：位于栈内存
 	成员变量：位于堆内存
 5.生命周期不一样（了解）
 	局部变量：随着方法进栈而诞生，随着方法出栈而消失（短一点）
 	成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失（长一点）
 */
public class Demo01VariableDifference {
	String name;//成员变量
	
	public void methodA() {
		int num = 20;//局部变量
		System.out.println(num);
		System.out.println(name);
	}
	public void methodB(int param) {//方法的参数就是局部变量
		//参数在方法调用的时候，必然会被赋值的。
		System.out.println(param);

		int age;//局部变量
		//System.out.println(age);//没赋值不能用
		//System.out.println(num);//错误写法
		System.out.println(name);
	}
}

 12.11 面向对象三大特征之封装性

package demo03;
/*
 面向对象三大特征：封装、继承、多态
 封装性在Java当中的体现：
 1.方法就是一种封装
 2.关键字private也是一种封装
 
封装就是将一些细节信息隐藏起来，对于外界不可见
 */
public class Demo02Method {
	public static void main(String[] args) {
		int[] array = {5, 15, 25, 20, 100};
		
		int max = getMax(array);
		System.out.println("最大值：" + max);
	}
	//给我一个数组，我还给你一个最大值
	public static int getMax(int[] array) {
		int max = array[0];
		for(int i = 1; i < array.length; i++) {
			if (array[i] > max) {
				max = array[i];
		}
	}	
		return max;
}
}

12.12 private关键字的作用及使用

package demo03;
/*
 问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来。
 解决方案：用private关键字将需要保护的成员变量进行修饰。
 
 一旦使用了private进行修饰，那么本类当中仍然可以随意访问
 但是！超出了本类范围之外就不能再直接访问了。
 
 间接访问private成员变量，就是定义一对Getter/Setter方法
 
 必须叫setXxx或者是getXxx命名规则。
 对于Getter来说，不能有参数，返回值类型和成员变量对应
 对于Setter来说，不能有返回值，参数类型和成员变量对应
 */
public class Person {
	String name;//姓名
	private int age;//年龄
	
	public void show() {
		System.out.println("我叫：" + name + "，年龄：" + age);
	}
	
	//这个成员方法，专门用于向age设置数据
	public void setAge(int num) {
		if(num < 100 && num >= 0) {//如果是合理情况
			age = num;
			}else {
				System.out.println("数据不合理！");
			}
		}
		//这个成员方法，专门用于获取age的数据
		public int getAge() {
			return age;
		}
}
package demo03;

public class Demo03Person {
	public static void main(String[] args) {
		Person person = new Person();
		person.show();
		
		person.name = "A";
		//person.age = -20;//直接访问private内容，错误写法！
		person.setAge(-20);
		person.show();
	}
}

12.13 练习使用关键字定义学生类

package demo03;
/*
 对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。
 */
public class Student {
	private String name;//姓名
	private int age;//年龄
	private boolean male;//是不是男性
	
	public void setMale(boolean b) {
		male = b;
	}
	public boolean isMale() {
		return male;
	}
	
	public void setName(String str) {
		name = str;
	}
	public String getName() {
		return name;
	}

	public void setAge(int num) {
		age = num;
	}
	public int getAge() {
		return age;
	}
}
package demo03;

public class Demo04student {
	public static void main(String[] args) {
		Student stu = new Student();
		
		stu.setName("A");
		stu.setAge(20);
		stu.setMale(true);
		
		System.out.println("姓名：" + stu.getName());
		System.out.println("年龄：" + stu.getAge());
		System.out.println("是不是男性：" + stu.isMale());
	}
}

12.14 this关键字的作用

package demo04;
/*
 当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量
 如果需要访问本类当中的成员变量，需要使用格式；
 this.成员变量名
 
 “通过谁调用的方法，谁就是this”
 */
public class Person {
	String name;//我自己的名字
	
	//参数name是对方的名字
	//成员变量name是自己的名字
	public void sayHello(String name) {
		System.out.println(name + "，你好。我是" + this.name);
		System.out.println(this);
	}
}
package demo04;

public class Demo01Person {
	public static void main(String[] args) {
		Person person = new Person();
		//设置我自己的名字
		person.name = "A";
		person.sayHello("B");
		
		System.out.println(person);//地址值
	}
}

12.15 构造方法

package demo04;
/*
 构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
 格式：
 public 类名称（参数类型 参数名称）{
 	方法体
 }
 
 注意事项：
 1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
 2.构造方法不要写返回值类型，连void都不写
 3.构造方法不能return一个具体的返回值
 4.如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数，方法体什么事情都不做
 public Student(){}
 5.一旦编写了至少一个构造方法，那么编译器将不再赠送
 6.构造方法也是可以进行重载的。
 重载：方法名称相同，参数列表不同
 */
public class Student {
	
	//成员变量
	private String name;
	private int age;
	
	//无参数的构造方法
	public Student() {
		System.out.println("无参构造方法执行啦！");
	}
	
	//全参数的构造方法
	public Student(String name, int age) {
		System.out.println("全参构造方法执行啦！");
		this.name = name;
		this.age = age;
	}
	
	//Getter Setter
	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;
	}
}
package demo04;

public class Demo02Student {
	
	public static void main(String[] args) {
		Student stu1 = new Student();//无参构造
		System.out.println("==========");
		Student stu2 = new Student("A", 20);//全参构造
		System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
	//如果需要改变对象当中的成员变量数据内容，仍然还需要使用setXxx方法
		stu2.setAge(21);
		System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
	}
}

12.16 定义一个标准的类

package demo05;
/*
 一个标准的类通常要拥有下面四个组成部分：
 1.所有的成员变量都要使用private关键字修饰
 2.为每一个成员变量编写一对儿Getter/Setter方法
 3.编写一个无参数的构造方法
 4.编写一个全参数的构造方法
 
 这样的类也叫做Java Bean
 */
public class Student {
	
	private String name;//姓名
	private int age;//年龄
	
	//自动生成：Code-Generate-Constructor-Select None
	public Student() {
		
	}
	
	//自动生成：Code-Generate-Constructor-全选
	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	
	//自动生成：Code-Generate-Getter and Setter
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
 

}
package demo05;

public class Demo01Student {
	
	public static void main(String[] args) {
		Student stu1 = new Student();
		stu1.setName("A");
		stu1.setAge(10);
		System.out.println("姓名：" + stu1.getName() + "，年龄：" + stu1.getAge());
		System.out.println("=======");
		
		Student stu2 = new Student("B", 21);
		System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
		stu2.setAge(22);
		System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
	}

}

狗丢了就丢了吧
关注
专栏目录
输入一批整数，使用循环求出最大值与最小值，输入0时结束
weixin_44458686的博客
04-17 5110
package com.Summer_0417.cn; import java.util.Scanner; /** * @author Summer * 输入一批整数，使用循环求出最大值与最小值，输入0时结束。 * */ public class Test_Method11 { public static void main(String[] args) { //声明一下最大最...
Java基础语法
单一云
08-10 361
1、注释 public class HelloWorld { public static void main(String[] args) { //Ⅰ 单行注释 //输出HelloWorld System.out.println("HelloWorld"); //Ⅱ 多行注释 /* 内容 */ /* 注释如何设置颜色 ①在 File 查找并点击 Setting ②点击
特殊计算法
weixin_66312402的博客
04-28 683
import jdk.swing.interop.SwingInterOpUtils; import java.util.Arrays; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); while (sc.hasNext()){ int le.
石头剪刀布游戏2.0
Sunblogy的博客
11-06 2185
问题： 有个人 Tom 设计他的成员变量、成员方法。可以电脑猜拳，电脑每次会随 0表示石头，1表示剪刀，2表示布，并要可以显示Tom的输赢次数（清单），以3局为例： import jdk.swing.interop.SwingInterOpUtils; import java.util.Random; import java.util.Scanner; /** * @Author wanghaiyang * id ************ * @date 2021/11/6 16:05 */
Java邻接矩阵实现图的Dijkstra和Floyd算法
weixin_44632459的博客
04-26 520
package Graph; import jdk.swing.interop.SwingInterOpUtils; import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedList; import java.util.Queue; //邻接矩阵实现有向带权重图,及bfs，dfs，prim算法、k...
第12章 面向对象编程（下）.pptx
05-21
### 第12章 面向对象编程（下） #### 封装 封装是面向对象编程的一个核心概念，它的主要目的是隐藏对象的具体实现细节，并对外提供一个清晰的接口。这样做的好处是可以保护对象的内部状态不被外部非法访问或者修改...
软件开发基础课程 软件工程导论 第12章 面向对象的设计与实现 共40页.pptx
最新发布
06-22
### 软件开发基础课程：面向对象的设计与实现 #### 12.1 面向对象设计准则 面向对象设计（Object-Oriented Design, OOD）是指在软件开发过程中采用面向对象方法学来设计软件系统的一种方法。本章节重点介绍了面向...
软件工程导论课件之第12章 面向对象实现(第五版)(张海藩编著).pptx
09-21
软件工程导论课件之第12章 面向对象实现(第五版)(张海藩编著).pptx
计算机后端-Java-Java核心基础-第12章 面向对象04 23. Object类的理解.avi
05-22
计算机后端-Java-Java核心基础-第12章 面向对象04 23. Object类的理解.avi
计算机后端-Java-Java核心基础-第12章 面向对象04 21. 继承性的使用.avi
05-22
计算机后端-Java-Java核心基础-第12章 面向对象04 21. 继承性的使用.avi
【JAVA学习记录】用Swing实现天气工具
TinyBamboo的博客
05-07 1156
使用JAVA编写了一个基于swing的天气小工具。
Java学习 - 黑马（第二部分） - 随堂笔记 - 08_常用API
qq_43104872的博客
04-17 2799
Java学习 - 黑马（第二部分） - 随堂笔记 - 08_常用API 1. Math 1.1 Math类概述 Math包含执行基本数字运算的方法 没有构造方法，如何使用类中的成员呢？——通过查看帮助文档 看类的成员是否都是静态的，如果是，通过类名就可以直接调用 1.2 Math类的常用方法 package com.itheima; import jdk.swing.interop.SwingInterOpUtils; /* Math类的常用方法 */ public class Mat
Java邻接矩阵表示graph并实现prim和kruskal算法
weixin_44632459的博客
04-21 525
package Graph; import jdk.swing.interop.SwingInterOpUtils; import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedList; import java.util.Queue; //邻接矩阵实现有向带权重图,及bfs，dfs，prim算法和k...
java入坑系列1--安装JDK
zhtanjy819的博客
05-04 193
安装JDK安装JDK在window中安装java的jdk 安装JDK 你好！ 这是我重新全面学习java。会总结这一过程中的点点滴滴，主要为记录知识点和遇到的种种坑。希望能在学习路上的你有的帮助。 在window中安装java的jdk 清除原来的旧的java安装痕迹 原window使用久了会有其他软件安装自己相关的java，例如oracle。可以通过环境变量找出与java相关的指向路径加以删除。...
通过idea使用jdbc对数据进行增删改查的操作
qq_25337171的博客
08-27 1478
通过idea使用jdbc对数据进行增删改查的操作 DAO包 package util; import java.sql.*; public class BaseDao { //连接数据库 public Connection getConnection() { try { Class.forName(“com.mysql.jdbc.Driver”); String url = “jdbc:mysql...
Java常用类库——String类中方法的详解（2）
weixin_56939868的博客
02-19 340
Java常用类中对于String类的详解
图的邻接矩阵表示-Java语言实现
天天向上
03-04 437
【动态规划】分组背包解决课程价值最大化问题（java）
shixixiya6的博客
12-11 660
分组背包问题区别于01背包： 在我的理解范围内分组背包为每一组至多有一个被选择，而01背包是针对于某一个物品来说，分组背包是针对某几组物品来说每组至多选择一个，关键在于如何协调每组中的价值最大的物品。 问题转换描述： 有 N 组物品和一个容量是 V 的背包。 每组物品有若干个，同一组内的物品最多只能选一个。 每件物品的体积是 v[i][j]，价值是 w[i][j]，其中 i 是组号，j 是组内编号。 求解将哪些物品装入背包，可使物品总体积不超过背包...
Java基础语法--06.变量、常量、作用域
单一云
07-21 141
⑥变量、常量、作用域 以下内容来自【狂神说Java】Java零基础学习视频通俗易懂P26 以及我个人的理解。这个知识点看不懂的，建议看视频，动手操作一下. 如果对 数据类型 还不理解的可以去我整理的 ③数据类型 进行复习。 第一部分：变量 个人概念总结 (看过视频，然后还看不懂的，过段时间再看，别放弃Never give up)： 变量： 其实就是可以装东西的箱子(抽象、实体都能装)。 三部分组成：变量名、变量类型、作用域 变量名: 这个箱子的名字叫什么。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值