Java-day05（面向对象-1）

面向对象

面向对象与面向过程的区别：

面向过程，强调功能行为；面向对象，强调功能的对象。

1.Java类及类成员

• 类：对一类事物描述，是抽象的，概念上的定义
• 对象：实际存在的该类事物的每个个体，也称实例
  - 属性：对应类中的成员变量
  Field = 属性 = 成员变量
• 行为：对应类中的成员方法
  Method = (成员)方法 = 函数

Java用类class来描述事物

面向对象的编程关注类的设计（实际上是设计类的成员（方法 & 属性））

面向对象思想的落地

1. 设计类，并设计类的成员（成员变量&成员方法）
2. 通过类，来创建类的对象（即类的实例化）
3. 通过"对象.属性"或"对象.方法"来调用，完成相应的功能
   例：

public class Test {                            
    public static void main(String[] args) {     
		//2.类的实例化 （类似基本数据类型的声明：数据类型 变量名 = 初始化值）  
		Person a1 = new Person();
		//3.1 类的属性的调用
		a1.name = "小王";
		a1.age = 60;
		System.out.println("打印1：" + a1.name + a1.age);
		//3.2 类的方法的调用
		a1.eat();
		a1.info();
	}
}
//1.创建类
class Person{
	//属性
	String name;
	int age;
	boolean sex;
	//方法
	public void eat(){
		System.out.println("我饿了！");
	}
	public void sleep(){
		System.out.println("好困啊！");
	}
	public String getName(){
		return name;
	}
	public void setName(String n){
		name = n;
	}
	public void info(){
		eat();
		sleep();
	}
}

类对象的内存空间（与一维数组类似）

创建多个对象时，对象之间互不影响，对其中一个对象的属性进行修改，不会影响到其他对象的属性值

注意观察变化的代码及箭头

public class Test {              
    public static void main(String[] args) {     
		  
		Person a1 = new Person();
		
		a1.name = "花花";
		a1.age = 60;
		a1.setName("小花");

		Person a2 = a1;
		System.out.println(a1);
		System.out.println(a2);
		a2.info();

		System.out.println();

		a2 = new Person();
		System.out.println(a1);
		System.out.println(a2);
		a2.info();
	}
}
class Person{
	String name;
	int age;
	boolean sex;
	public void eat(){
		System.out.println("我饿了！");
	}
	public void sleep(){
		System.out.println("好困啊！");
	}
	public String getName(){
		return name;
	}
	public void setName(String n){
		name = n;
	}
	public void info(){
		System.out.println("name:"  + name + "age: " + age);
	}
}

类的属性

成员变量与局部变量的相同与不同？
相同：

1. 都遵循变量声明的格式：数据类型 变量名 = 初始化值
2. 都有作用域

不同：

1. 声明的位置不同：成员变量（声明在类里，方法外）局部变量（声明在方法内,方法的形参,代码块）
2. 成员变量的修饰符有4个：public,private,protected,缺省 ；局部变量无修饰符，与所在方法修饰符相同
3. 初始化值：一定会有初始化值，成员变量：如果在声明时，不显性赋值，那么不同的数据类型会有不同的默认初始化值；局部变量：一定要显式的赋值。(局部变量没有默认的初始化值)
4. 二者内存存放位置不同：成员变量存在于堆空间，局部变量存在于栈空间

总结：
变量分类：
1.按数据类型分类：基本数据类型（8种）& 引用数据类型
2.按声明的位置不同：成员变量 & 局部变量

类的方法

提供某种功能的实现

例：

public void eat(){}     
public String getName(){}
public void setName(String n){}

格式：权限修饰符 返回值类型（void:无返回值/具体返回值) 方法名(形参){}

1. 返回值类型：void:不需要返回值；有返回值的一定要在return + 返回值类型对应的变量（return语句后的语句不在继续执行）
2. 可以在方法内调用本类的其他方法与访问本类中的成员变量，但不能在方法中定义方法
3. 不是属性的语句能在方法中存在，不能在类中单独存在

练习题

题一

public class Test {      
    public static void main(String[] args) {     
		  
		Person a1 = new Person();
		a1.study();
		a1.showAge();
		a1.addAge(2);
		a1.showAge();
		Person a2 = new Person();
		a2.showAge();
	}
}		
class Person{  
	String name;
	int age;
	int sex;
	public void study(){
		System.out.println("Studying！");
	}
	public void showAge(){
		System.out.println(age);
	}
	public int addAge(int i){
		age += i;
		return age;
	}
}

题二

将求最大值，最小值，遍历数组元素，总和，平均数，反转，复制，排序写成一个类

public class Test {           
    public static void main(String[] args) {   
		double[] arr = new double[]{12.1,-0.2,22,332.4342,443.42134,322,-2233,1,0};
		Person a1 = new Person();

		double max = a1.getMax(arr);
		System.out.println("最大值：" + max);
		double avg = a1.getAvg(arr);
		System.out.println("平均值：" + avg);
		//遍历
		System.out.println("数组遍历：");
		a1.getAll(arr);
		//反转
		System.out.println("数组反转：");
		a1.reverse(arr);
		a1.getAll(arr);
		//排序
		System.out.println("从小到大排列：");
		a1.sort(arr);
		a1.getAll(arr);
	}
}		
class Person{  
	//数组最大值
	public double getMax(double[] arr){
		double max = arr[0];
		for(int i = 1;i < arr.length;i++){
			if(max < arr[i]){
				max = arr[i];
			}
		}
		return max;
	}

	//数组最小值
	public double getMin(double[] arr){
		double min = arr[0];
		for(int i = 1;i < arr.length;i++){
			if(min > arr[i]){
				min = arr[i];
			}
		}
		return min;
	}

	//求数组的遍历
	public void getAll(double[] arr){
		System.out.println("[");
		for(int i = 1;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
		System.out.println("]");
	}
	//求数组总和值
	public double getSum(double[] arr){
		double sum = 0;
		for(int i = 0;i < arr.length;i++){
			sum += arr[i];
		}
		return sum;
	}
	//求数组平均值
	public double getAvg(double[] arr){
		double sum = getSum(arr);
		double avg = sum/arr.length;
		return avg;
	}
	
	//求数组反转
	public double[] reverse(double[] arr){
		for(int x = 0,y = arr.length-1;x < y;x++,y--){
			double temp = arr[x];
			arr[x] = arr[y];
			arr[y] = temp;
		}
		return arr;
	}
	//求数组复制
	public double[] Copy(double[] arr){
		double[] arr1 = new double[arr.length];
		for(int i = 0;i < arr.length;i++){
			arr1[i] =arr[i];
		}
		return arr1;
	}
	//求数组排序(冒泡排序)
	public void sort(double[] arr){
		for(int i = 0;i < arr.length - 1;i++){
			for(int j = 0;j < arr.length - 1;j++){
				if(arr[j] > arr[j + 1]){
					double temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
	}
}

重载

要求：同一个类中；方法名必须相同；方法的参数列表不同（参数的个数不同，参数类型不同）

补充：方法的重载与方法的返回值类型没有关系

public class Test {        
    public static void main(String[] args) {  
		Person a1 = new Person();
		a1.get(1,1.0,1.1);
}
class Person{
	public int get(int i,int j){
		return i + j;
	}
	public int get(int i,int j,int k){
		return i + j + k;
	}
	public int get(double i,double j,double k){
		return i + j + k;
	}
	public double get(int i,double j,double k){
		return i + j +k;
	}
}

练习题

1

部分代码

2

3

感谢大家的支持，关注，评论，点赞！
参考资料：
尚硅谷宋红康20天搞定Java基础上部
89