Java 第二周

面向对象的三条主线

（1）类及类的成员：属性、方法、构造器、代码块、内部类

（2）面向对象的三大特征：封装、继承、多态

（3）其他关键字：this 、super、、、、、、

面向对象的编程思想

（类、对象；卖你想对象的三大特征；。。。）

理解万事万物皆对象

1.在Java中，我们都将功能呢给、结构等封装到类中，通过类的实例化，来具体调用的功能结构

2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。

内存解析的说明

1.引用类型的变量，只可能存储两类值：null 或地址值（含变量的类型）

练习题：

定义类students；包含三个属性：学号number（int），年级state（int),成绩score（int）

创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。

问题一：打印出三年级（state值为3）的学生信息

问题二：使用冒泡排序按学生的成绩进行排序，并输出学生信息

提示：

(1)生成随机数：

生成区间[m,n]的一个随机数 （Math.radom()*（m-n+1)+m),返回值类型double;

(2)四舍五入取整： Math.roud (double d),返回值类型long。

public class StudentTest1 {
	public static void main(String[] args) {
		
		//声明Student类型的数组
		Student1[] stus = new Student1[20];  
		
		for(int i = 0;i < stus.length;i++){
			//给数组元素赋值
			stus[i] = new Student1();
			//给Student对象的属性赋值
			stus[i].number = (i + 1);
			//年级：[1,6]
			stus[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
			//成绩：[0,100]
			stus[i].score = (int)(Math.random() * (100 - 0 + 1));
		}
		
		StudentTest1 test = new StudentTest1();
		
		//遍历学生数组
		test.print(stus);
		
		System.out.println("********************");
		
		//问题一：打印出3年级(state值为3）的学生信息。
		test.searchState(stus, 3);
		
		System.out.println("********************");
		
		//问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
		test.sort(stus);
		
		//遍历学生数组
		test.print(stus);
		
	}
	

	public void print(Student1[] stus){
		for(int i = 0;i <stus.length;i++){
			System.out.println(stus[i].info());
		}
	}

	public void searchState(Student1[] stus,int state){
		for(int i = 0;i <stus.length;i++){
			if(stus[i].state == state){
				System.out.println(stus[i].info());
			}
		}
	}
	

	public void sort(Student1[] stus){
		for(int i = 0;i < stus.length - 1;i++){
			for(int j = 0;j < stus.length - 1 - i;j++){
				if(stus[j].score > stus[j + 1].score){
					//如果需要换序，交换的是数组的元素：Student对象！！！
					Student1 temp = stus[j];
					stus[j] = stus[j + 1];
					stus[j + 1] = temp;
				}
			}
		}
	}
	
	
}

class Student1{
	int number;//学号
	int state;//年级
	int score;//成绩
	
	//显示学生信息的方法
	public String info(){
		return "学号：" + number + ",年级：" + state + ",成绩：" + score;
	}
	
}

匿名对象的使用

1.理解：创建的对象，没有显示的赋给一个变量名

2.特征：匿名对象只能调用一次

重载的概念：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数 类型不同即可。

 "两同一不同":同一个类、相同方法名
           参数列表不同：参数个数不同，参数类型不同

重载的特点：

判断是否是重载：

 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系，只看参数列表，且参数列表必须不同。(参数个数或参数类 型)。调用时，根据方法参数列表的不同来区别。

重载示例：

//返回两个整数的和

int add(int x,int y){return x+y;}

//返回三个整数的和

int add(int x,int y,int z){return x+y+z;}

返回两个小数的和

double add(double x,double y){return x+y;}

 可变个数形参的方法

具体使用：
    1 可变个数形参的格式：数据类型 ... 变量名
    2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
    3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
    4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
    5 可变个数形参在方法的形参中，必须声明在末尾

错误的使用方法

public void show(String ...strs,int i)

    6  可变个数形参在方法的形参中,最多只能声明一个可变形参。

方法参数的值传递机制

关于变量的赋值：
 
  如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
  如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据

System.exit(0);//终止当前程

递归方法的使用（了解）

 1.递归方法：一个方法体内调用它自身。
 2. 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

public class RecursionTest {

	public static void main(String[] args) {

		// 例1：计算1-100之间所有自然数的和
		// 方式一：
		int sum = 0;
		for (int i = 1; i <= 100; i++) {
			sum += i;
		}
		System.out.println(sum);
		// 方式二：
		RecursionTest test = new RecursionTest();
		int sum1 = test.getSum(100);
		System.out.println(sum1);
		
		System.out.println("*****************");
		int value = test.f(10);
		System.out.println(value);

	}

	// 例1：计算1-n之间所有自然数的和
	public int getSum(int n) {// 3

		if (n == 1) {
			return 1;
		} else {
			return n + getSum(n - 1);
		}

	}

	// 例2：计算1-n之间所有自然数的乘积:n!
	public int getSum1(int n) {

		if (n == 1) {
			return 1;
		} else {
			return n * getSum1(n - 1);
		}

	}
	
	//例3：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
	//其中n是大于0的整数，求f(10)的值。
	public int f(int n){
		if(n == 0){
			return 1;
		}else if(n == 1){
			return 4;
		}else{
//			return f(n + 2) - 2 * f(n + 1);
			return 2*f(n - 1) + f(n - 2);
		}
	}