稳稳当当学java之面向对象编程(8)

第十章 面向对象编程

1.作业回顾

1，找出数组中元素的最大值 。

public class Day101 {	
	public static int max(int[] arr) {
		int result = Integer.MIN_VALUE; //-2147483648
		for (int i = 0; i < arr.length; i++) {
			if(result < arr[i]) {
				result = arr[i];
			}	
		}
		return result;
	}
	public static void main(String[] args) {
		//1，找出数组中元素的最大值
		int[] arr = {20, 4, 16, 80};
		System.out.println(max(arr));	
	}
}

2，找出数组中元素的最大值和下标 。

public class Day102 {
	
	public static void max(int[] arr) {
		int result = Integer.MIN_VALUE;
		int index = 0;
		for (int i = 0; i < arr.length; i++) {
			if(result < arr[i]) {
				result = arr[i];
				index = i;
			}
		}
		System.out.println(result);
		System.out.println(index);
	}
	public static void main(String[] args) {
		//2，找出数组中元素的最大值和下标
		int[] arr = {20, 4, 16, 80};
		max(arr);
	}
}

3，数组反转[12345]—[54321]。

2.import java.util.Arrays;

public class Day103 {
	
	public static void reverse(int[] arr) {
		int temp = 0;
		for (int i = 0; i < arr.length/2; i++) {
			temp = arr[i];
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = temp;
		}
	}
	public static void main(String[] args) {
		//3，数组反转[12345]---[54321]
		//调整次数 = 数组长度/2
		int[] arr = {1, 2, 3, 4, 5};
		int[] arr1 = {1, 2, 3, 4, 5, 6};
		reverse(arr);
		System.out.println(Arrays.toString(arr));//[5, 4, 3, 2, 1]
	}
}

2.类和对象

java中的基本数据类型有8种。

对象是一种复杂的数据，一个对象可以由几种不同的基本类型的数据和对象组成。

上面的对象中包含了四个属性：name，age，gender，sno，类型分别是String， int， char， int 。

类决定了对象有哪些属性以及这些属性的类型，类是一种复杂的数据类型。

//创建一个Person类，Person是一种复杂的数据类型
//类相当于一个模板
public class Person {
	String name;
	int age;
	char gender;
	int sno;
}

通过类创建对象

public class Day104 {
	public static void main(String[] args) {
		//使用new操作符来创建一个Person类的对象p
		//因此p对象有四个属性name，age，gender，sno
		Person p = new Person();
		p.name = "张三"; //为对象p的name属性赋值
		p.age = 10;  //为对象p的age属性赋值
		p.gender = '男'; //为对象p的gender属性赋值
		p.sno = 20191101; //为对象p的sno属性赋值
		
		System.out.println(p.name); //输出对象p的name属性
		System.out.println(p.age); //输出对象p的age属性
		System.out.println(p.gender); //输出对象p的gender属性
		System.out.println(p.sno); //输出对象p的sno属性
		
		int age = p.age; //将对象p的age属性赋值给变量age
		System.out.println(age); //10
	}
}

类是一种类型，通过类可以创建出来很多对象。

public class Day105 {
	public static void main(String[] args) {
		// 使用new操作符来创建一个Person类的对象p1
		Person p1 = new Person();
		p1.name = "张三"; // 为对象p1的name属性赋值
		p1.age = 10; // 为对象p1的age属性赋值
		p1.gender = '男'; // 为对象p1的gender属性赋值
		p1.sno = 20191101; // 为对象p1的sno属性赋值

		// 使用new操作符来创建一个Person类的对象p2
		Person p2 = new Person();
		p2.name = "李四"; // 为对象p2的name属性赋值
		p2.age = 11; // 为对象p2的age属性赋值
		p2.gender = '女'; // 为对象p2的gender属性赋值
		p2.sno = 20191102; // 为对象p2的sno属性赋值
		
		//p1和p2类型相同，但是数据相互独立
		
		//输出对象p1的属性
		System.out.println(p1.name); //输出对象p1的name属性
		System.out.println(p1.age); //输出对象p1的age属性
		System.out.println(p1.gender); //输出对象p1的gender属性
		System.out.println(p1.sno); //输出对象p1的sno属性
		
		//输出对象p2的属性
		System.out.println(p2.name); //输出对象p2的name属性
		System.out.println(p2.age); //输出对象p2的age属性
		System.out.println(p2.gender); //输出对象p2的gender属性
		System.out.println(p2.sno); //输出对象p2的sno属性
	}
}

使用类创建对象的过程叫做实例化。

类是对象的蓝图（模板），而对象是类的实例。

生活中有很多类和对象的例子：人是类，张三是这个类的一个对象，李四也是这个类的一个对象。

手机是类，你现在手中的手机就是一个对象，我手中的手机也是一个对象。

类是一种类型，对象是具体的某一个实例。

3.实例方法

对象不仅有属性，还可以有实例方法。一个对象有哪些方法是由创建这个对象的类来决定的。

public class Day106 {
	public static void main(String[] args) {
		Person p = new Person();
		p.name = "张三";
		//调用对象p的getName方法，将获取对象p的name属性，并将其作为返回值赋值给name变量
		String name = p.getName();
		System.out.println(name); //张三
		
		Person p1 = new Person();
		p1.name = "李四";
		//调用对象p1的getName方法，将获取对象p1的name属性，并将其作为返回值赋值给name1变量
		String name1 = p1.getName();
		System.out.println(name1); //李四
		
		//调用对象p的setName方法，将张三1作为参数传递进去
		p.setName("张三1");
		//调用对象p1的setName方法，将李四1作为参数传递进去
		p1.setName("李四1");
		
		System.out.println(p.getName()); //张三1
		System.out.println(p1.getName()); //李四1
		
		//实例方法可以操作（输出/修改）调用此方法的对象的属性
		//p调用showInfo()方法就操作showInfo()方法的对象的属性
		p.showInfo();
		p1.showInfo();
	}
}

4.成员变量

在类的属性有三种：类变量（用static修饰的变量），实例变量（不使用static修饰的变量），类常量。

成员变量：类变量和实例变量都是成员变量。

public class Day107 {
	public static void main(String[] args) {
		Foo f = new Foo();
		//实例变量是属于对象的，通过对象来访问
		f.age =10;
		System.out.println(f.age); //10
		
		//类变量是属于类的，通过类名来访问
		Foo.count = 5;
		System.out.println(Foo.count); //5
		
		//类常量也是属于类的，通过类名来访问
		System.out.println(Foo.PI); //3.14
		
		//实例变量是属于对象的，实例变量的值是存放到对象中，每个对象都有一份，跟别的对象的实例变量是互相独立的
		//类变量是属于类的，类变量的值是存放到类中，由于类只有一个，因此类变量只有一份
		//类常量也是属于类的，也是只有一份		
	}
}

实例变量随对象的创建而创建，随对象的销毁而销毁。

类变量是在类加载时创建的。

类变量可以通过类名来访问，也可以通过对象来访问（不推荐）

实例变量只能通过对象来访问。

方法参数，方法中声明的变量，代码块中声明的变量都是局部变量，局部变量存储在栈内存中。局部变量可以是基本类型，也可是引用类型。局部变量在声明时创建，在所属块结束后销毁。

在类中声明的实例变量随对象存储在堆内存中，实例变量随对象的创建而创建，随对象的销毁而销毁。

对象什么时候销毁？当没有任何一个对象变量引用它时，它就会再某一个时间点被垃圾回收器销毁。

一个对象，如果有对象变量引用它，它就不会被销毁。

public class Day108 {
	//n, x, y, p都是局部变量，它们的作用域都是从声明时开始，所属块结束后销毁
	//p所引用的对象是在使用new操作符时创建，那么它的属性也是在这个时候创建
	//这个对象并不是在对象变量p销毁时销毁，它要等待垃圾回收器的回收
	public static void f(int n) {
		int x = 0;
		if(x == 0) {
			int y = 0;
		}
		//p是对象变量，它引用了一个对象
		//new Person();创建出来一个对象，将对象的引用（地址）赋值给对象变量p
		//p引用了刚创建的对象
		Person p = new Person();		
	}

	public static void main(String[] args) {
		f(1);
		new Person(); //这就是一个匿名对象，没有任何变量引用它，因此它可能刚创建出来就被销毁了
	}
}

5.练习

用了一个对象
//new Person();创建出来一个对象，将对象的引用（地址）赋值给对象变量p
//p引用了刚创建的对象
Person p = new Person();
}

public static void main(String[] args) {
	f(1);
	new Person(); //这就是一个匿名对象，没有任何变量引用它，因此它可能刚创建出来就被销毁了
}

}

[外链图片转存中...(img-wcQQhDET-1591067135873)]

## 5.练习

1，定义一个类Dog，它有age，name，color，String type。创建出来三个对象，赋值，并访问。