第五章 面向对象基础

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;
        }
    }
}

对象数组的内存图：