第五章 面向对象基础
5.1 类与对象
1、类：一类具有相同特性的事物的抽象描述。
对象：类的一个个体，实例，具体的存在。
类是对象的设计模板。
2、如何声明类？
【修饰符】 class 类名{
成员列表：属性、方法、构造器、代码块、内部类
}
3、如何创建对象？
new 类名(); //匿名对象
类名 对象名 = new 类名(); //有名对象
5.2 类的成员之一：属性
1、如何声明属性？
【修饰符】 class 类名{
【修饰符】 数据类型 属性名; //属性有默认值
【修饰符】 数据类型 属性名 = 值; //属性有初始值
}
说明：属性的类型可以是Java的任意类型，包括基本数据类型、引用数据类型（类、接口、数组等）
总结：Java的数据类型
（1）基本数据类型
byte,short,int,long,float,double,char,boolean
（2）引用数据类型
①类：
例如：String、Student、Circle、System、Scanner、Math…
②接口：后面讲
③数组：
例如：int[]，String[]，char[]，int[][]
int[] arr = new int[5];
这里把int[]看成数组类型，是一种引用数据类型，右边赋值的是一个数组的对象
元素的数据类型：int
数组的数据类型：int[]
2、如何为属性赋值？
（1）在声明属性时显式赋值
【修饰符】 class 类名{
【修饰符】 数据类型 属性名 = 值; //属性有初始值
}
代码示例：
class Student{
String name;
char gender = '男';//显式赋值
}
class TestStudent{
public static void main(String[] args){
Student s1 = new Student();
System.out.println("姓名：" + s1.name);//null
System.out.println("性别：" + s1.gender);//男
s1.name = "小薇";//修改属性的默认值
s1.gender = '女';//修改属性的初始值
System.out.println("姓名：" + s1.name);//小薇
System.out.println("性别：" + s1.gender);//女
Student s2 = new Student();
System.out.println("姓名：" + s2.name);//null
System.out.println("性别：" + s2.gender);//男
}
}
（2）创建对象之后赋值
【修饰符】 class 类名{
【修饰符】 数据类型 属性名; //属性有默认值
}
//创建对象
类名 对象名 = new 类名();
//为对象的属性赋值
对象名.属性名 = 值;
3、如何访问属性的值？
（1）在本类的方法中访问
示例代码：
class Circle{
double radius;
double getArea(){
return 3.14 * radius * radius;//直接访问
}
}
（2）在其他类的方法中访问
class Circle{
double radius;
}
class TestCircle{
public static void main(String[] args){
Circle c1 = new Circle();
double area = 3.14 * c1.radius * c1.radius;//对象名.属性名
}
}
4、属性的特点
（1）属性有默认值
基本数据类型：
byte,short,int,long：0
float，double：0.0
char：\u0000
boolean：false
引用数据类型：
null
（2）每一个对象的属性是独立，互不干扰
5、对象属性的内存图
class Student{
String name;
char gender = '男';//显式赋值
}
class TestStudent{
public static void main(String[] args){
Student s1 = new Student();
System.out.println("姓名：" + s1.name);//null
System.out.println("性别：" + s1.gender);//男
s1.name = "小薇";
s1.gender = '女';
System.out.println("姓名：" + s1.name);//小薇
System.out.println("性别：" + s1.gender);//女
Student s2 = new Student();
System.out.println("姓名：" + s2.name);//null
System.out.println("性别：" + s2.gender);//男
}
}
5.3 类的成员之二：方法
5.3.1 方法的概念
方法也叫函数，是一个独立功能的定义，是一个类中最基本的功能单元。
把一个功能封装为方法的目的是，可以实现代码重用，从而简化代码。
方法的使用原则：
（1）必须先声明后使用
类，变量，方法都要先声明后使用
（2）不调用不执行，调用一次执行一次。
5.3.2 方法的声明格式
（1）方法声明的位置
类中方法外
（2）方法的声明格式
【修饰符】 返回值类型 方法名(【形参列表】){
//方法体：实现功能的语句
}
说明：
- 方法名：代表功能，见名知意，好的方法名，看到方法，就能知道方法的功能是什么
- 修饰符：方法的修饰符很多，将会一一学习，例如：public，static等
- 返回值类型：说明方法运行后有结果返回，那个结果的数据类型。如果无需返回结果，只能写void
return语句
（1）return; 用于提前结束方法。用于返回值类型是void的方法中，可选。
（2）return 返回值; 用于结束方法并返回结果。用于返回值类型不是void的方法中，必选。return后面返回值的数据类型与方法签名中的返回值类型必须一致或兼容
- 参数列表：属于方法的局部变量，可以有0~n个，每个参数需要指明“数据类型
形参名”，数据类型与形参名之间用“空格”分割，而多个参数之间使用“,”分割。形参的值，在方法被调用时由实参决定。
（3）声明方法前需要明确的几点
方法的功能是什么，取个“好名”
原则：方法名要见名知意，而且一个方法实现一个独立的完整的功能
例如Math数学工具类：
求平方根：sqrt()
获取随机数：random()
数组工具类：
排序：sort()
复制：copyOf()
copyOfRange()
- 明确是否需要返回结果给调用者
- 明确是否需要返回值类型，返回值类型是什么 原则：尽量让方法中最后的输出改装成返回值
- 明确是否有对象属性以外的未知的数据参与运算
- 明确是否需要参数，需要几个参数，分别是什么类型的 原则：尽量让方法中输入的数据改装成参数
- 明确是否该方法的访问有什么限制和要求，即考虑修饰符（后续讲解）
- 明确是否该方法会抛出什么异常（后续讲解）
5.3.3 方法的调用格式
5.3.4 方法的四种形式
根据有参无参，有返回值无返回值，排列组合后方法有4种情形：
（1）无返回值无参数
（2）有返回值无参数
（3）无返回值有参数
（4）有返回值有参数
class Circle{
double radius;
//封装一个求面积的方法
//或者说，圆这个类别的对象，就应该有获取面积的功能
double getArea(){
double area = Math.PI * radius * radius;
return area;
}
//封装一个求周长的方法
double getZhouChang(){
return 2 * Math.PI * radius;
}
void printInfo(){
System.out.println(“半径：” + radius +”，面积是：” + getArea() + “，周长：” + getZhouChang());
}
}
class TestMethod{
public static void main(String[] args){
//1、先创建对象
Circle c = new Circle();
//2、获取c对象的面积
double area = c.getArea();
System.out.println("area=" + area);
//3、为属性赋值
c.radius = 3.0;
System.out.println("面积是：" + c.getArea());
System.out.println("周长是：" + c.getZhouChang());
}
}
/*
定义银行账户类Account，有属性：卡号cid，余额balance
银行账户类Account有方法：
（1）getInfo()，返回String类型，返回卡的详细信息
（2）取钱方法withdraw()，参数自行设计，如果取钱成功返回true，失败返回false
（3）存钱方法save(),参数自行设计，如果存钱成功返回true,失败返回false
*/
public class TestMethod {
public static void main(String[] args) {
Account a = new Account();
a.cid = "11223344";
a.balance = 1000;
System.out.println(a.getInfo());
boolean flag = a.withdraw(2000);
System.out.println(flag?"取钱成功":"取钱失败");
System.out.println(a.getInfo());
boolean result = a.deposit(1000);
System.out.println(result?"存钱成功":"存钱失败");
System.out.println(a.getInfo());
}
}
class Account{
String cid;
double balance;
boolean withdraw(double money){
if(money<0 || money > balance){
return false;
}
balance -= money;
return true;
}
boolean deposit(double money){
if(money<0){
return false;
}
balance += money;
return true;
}
String getInfo(){
return "账户：" + cid + "，余额：" + balance;
}
}
5.3.5 方法参数的值传递机制
1、基本数据类型
public class TestPassValue{
public static void main(String[] args){
int a = 10;
System.out.println("修改之前a = " + a);//10
//a是实参
change(a);
System.out.println("修改之后a = " + a);//10
}
//方法的功能：修改一个变量的值，为它原来的两倍
//修饰符 返回值类型 方法名（形参列表）{}
//修饰符：public static，和main在同一个类中，为了在main()中直接调用，这里加上public static
//int num是形参
public static void change(int num){
System.out.println("修改之前num = " + num);//10
num *= 2;
System.out.println("修改之后num = " + num);//20
}
}
修改之前a = 10
修改之前num = 10
修改之后num = 20
修改之后a = 10
2、引用数据类型
/*
Java的数据类型：
（1）基本数据类型（8种）
（2）引用数据类型：
类、接口、数组
类的类型：Student,Circle,String等
String name = "张三";
Circle circle = new Circle();
*/
public class TestPassValue2{
public static void main(String[] args){
//1、创建圆对象
Circle circle = new Circle();
circle.radius = 1.0;
System.out.println("circle的半径是：" + circle.radius);//1.0
//2、调用changeRadius方法，修改半径的值
//实参要与形参的类型，个数，顺序一致
changeRadius(circle);
System.out.println("circle的半径是：" + circle.radius);//2.0
}
//把c这个圆的半径修改为原来的两倍
//形参的格式：数据类型 形参名
public static void changeRadius(Circle c){
System.out.println("c的半径是：" + c.radius);//1.0
c.radius *= 2;
System.out.println("c的半径是：" + c.radius);//2.0
}
}
class Circle{
double radius;
}
5.3.6 方法重载
方法的重载：在同一个类中，出现的多个方法名称相同，参数列表不同的情形称为方法重载。
关键词：
（1）在同一个类中多个方法
（2）方法名称必须相同
（3）参数列表必须不同（参数的个数或数据类型不同）
注意：与返回值类型无关
/*
面试题：Overload和Override的区别？
方法的重载：Overload
在同一个类中，出现了方法名称相同，方法的形参列表不同，这样的两个或多个方法，称为方法的重载。
和返回值类型无关。
关键词：（1）同一个类中 （2）方法名称相同 （3）形参列表不同：个数或类型
*/
public class TestOverload{
public static void main(String[] args){
int x = 4;
double y = 9;
//1、创建对象
MyMath m = new MyMath();
//double max = m.getMax(x,y);
//System.out.println("x,y中的较大者是：" + max);
int r = 1;
int s = 0;
int t = 4;
int big = m.getMax(r,s,t);
System.out.println("r,s,t中的较大者是：" + big);
}
}
class MyMath{
//方法一：返回两个整数中的较大者
public int getMax(int a, int b){
System.out.println("两个整数的最大值");
//写法一：
/*
int max = a>=b ? a : b;
return max;
*/
return a>=b ? a : b;
}
//方法二：返回两个浮点数，小数中的较大者
public double getMax(double a, double b){
System.out.println("两个小数的最大值");
//写法二：
if(a>=b){
return a;
}else{
return b;
}
}
//方法三：返回三个整数中的最大值
public int getMax(int a, int b, int c){
System.out.println("三个整数的最大值");
/*
int max = a>=b ? a : b;
max = max >= c ? max : c;
return max;
*/
/*
int max = getMax(a,b);
max = getMax(max,c);
return max;
*/
/*
int max = getMax(getMax(a,b),c);
return max;
*/
return getMax(getMax(a,b),c);
}
}
5.4 对象数组
一维数组：
1、元素是基本数据类型
2、元素是引用数据类型，也称为对象数组，即数组的元素是对象
注意：对象数组，首先要创建数组对象本身，即确定数组的长度，然后再创建每一个元素对象，如果不创建，数组的元素的默认值就是null，所以很容易出现空指针异常NullPointerException。
示例代码：
class MyDate{
int year;
int month;
int day;
}
class Test{
public static void main(String[] args){
MyDate[] arr = new MyDate[3];//创建数组对象本身，指定数组的长度
for(int i=0; i<arr.length; i++){
arr[i] = new MyDate();//每一个元素要创建对象
arr[i].year = 1990 + i;
arr[i].month = 1 + i;
arr[i].day = 1 + i;
}
}
}
对象数组的内存图：
