30天搞定Java--day9

每日一考和复习

每日一考

1. 面向对象思想编程内容的三条主线分别是什么

1. 类及类的成员：属性、方法、构造器；代码块、内部类
2. 面向对象的三大特征：封装、继承、多态
3. 其它关键字：this、super、abstract、interface、static、final、package、import

2. 谈谈你对面向对象中类和对象的理解，并指出二者的关系?

类：抽象的、概念上的内容
对象：实实在在存在的一个个体
对象是由类派生出来的

3. 面向对象思想的体现一：类和对象的创建和执行操作有哪三步？

// 我的答案
1.创建类，定义属性
2.创建方法
3.实例化
// 参考答案
1.创建类
2.类的实例化
3.调用对象的结构：“对象.属性”“对象.方法”

4. 画出如下代码在执行时的内存分配情况

class Car{
    String color = "red";
    int num = 4;
    void show(){
  	int a = 10;
    System.out.println("color="+color+",num="+num);
    }
}
class CarTest {
	public static void main(String[] args) {
		Car c1 = new Car();   
	    Car c2 = new Car(); 
		c1.color = "blue";  
		c1.show();   
		c2.show();
	}  
}

5. 类的方法内是否可以定义变量？是否可以调用属性？是否可以定义方法？是否可以调用方法？

1.类的方法内可以定义变量
2.可以调用属性
3.不可以定义方法
4.可以调用方法

复习
day8的学习内容

补充知识点

• JVM内存结构
  1. 编译完源程序以后，生成一个或多个字节码文件
  2. 我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。
• 理解“万事万物皆对象”
  1. 在Java语言范畴中，我们将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
     ->Scanner,String等
     ->文件：File
     ->网络资源：URl
  2. 涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
• 匿名对象
  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;}

• 练习题一

判 断：
与void show(int a,char b,double c){}构成重载的有：
a) void show(int x,char y,double z){} // no
b) int show(int a,double c,char b){} // yes
c) void show(int a,double c,char b){} // yes
d) boolean show(int c,char b){} // yes
e) void show(double c){} // yes
f) double show(int x,char y,double z){} // no
g) void shows(){double c} // no，方法名不一样

• 练习题二

/*
 * 1.编写程序，定义三个重载方法并调用。方法名为mOL。
	三个方法分别接收一个int参数、两个int参数、一个字符串参数。
	分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
	在主类的main ()方法中分别用参数区别调用三个方法。
	
	2.定义三个重载方法max()，
	第一个方法求两个int值中的最大值，
	第二个方法求两个double值中的最大值，
	第三个方法求三个double值中的最大值，
	并分别调用三个方法。
 */
public class OverloadExer {
	
	//1. 如下的三个方法构成重载
	public void mOL(int i){
		System.out.println(i * i);
		
	}
	public void mOL(int i,int j){
		System.out.println(i * j);
	}
	
	public void mOL(String s){
		System.out.println(s);
	}
	
	//2.如下的三个方法构成重载
	public int max(int i,int j){
		return (i > j)? i : j;
	}
	public double max(double d1,double d2){
		return (d1 > d2)? d1 : d2;
	}
	public double max(double d1,double d2,double d3){
		double max = (d1 > d2)? d1 : d2;
		return (max > d3)? max : d3;
	}
}

可变形参的方法

• JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String…books);

说明：

1. 声明格式：方法名(参数的类型名 …参数名)
2. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
3. 可变个数形参的方法与同名的方法之间，彼此构成重载
4. 可变参数方法的使用与方法参数部分使用数组是一致的
5. 方法的参数部分有可变形参，需要放在形参声明的最后
6. 在一个方法的形参位置，最多只能声明一个可变个数形参

方法参数的值传递机制

• 方法，必须由其所在类或对象调用才有意义。若方法含有参数：
  • 形参：方法声明时的参数
  • 实参：方法调用时实际传给形参的参数值
• Java的实参值如何传入方法呢？
  Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响
  • 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
  • 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

例题1

public class TransferTest1 {
	public void swap(int a, int b) {
		int tmp = a; 
		a = b; 
		b = tmp;
		System.out.println("swap方法里，a的值是" + a + "；b的值是" + b);
	}
	public static void main(String[] args) {
		TransferTest1 test = new TransferTest1();
		int a = 5;
		int b = 10;
		test.swap(a, b);
		System.out.println("交换结束后，变量a的值是" + a + "；变量b的值是" + b);
	} 
}
// 输出：
swap方法里，a的值是10；b的值是5
交换结束后，变量a的值是5；变量b的值是10

例题1的内存解析

例题2

public class TransferTest3 {
	public static void main(String args[]) {
		TransferTest3 test = new TransferTest3();
		test.first();
	}
	public void first() {
		int i = 5;
		Value v = new Value();
		v.i = 25;
		second(v, i);
		System.out.println(v.i);
	}
	public void second(Value v, int i) {
		i = 0;
		v.i = 20;
		Value val = new Value();
		v = val;
		System.out.println(v.i + " " + i);
	} 
}
class Value {
	int i = 15;
}
// 输出：
15 0
20

例题3的内存解析

递归算法(暂时了解)

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

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

	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 2*f(n - 1) + f(n - 2);
	}
}