尚硅谷_Java零基础教程（面向对象上）--学习笔记（十）

package com.itguigu.java;

/*
 * 一、理解“万事万物皆对象”
 * 1、在Java语言范畴中，我们都将功能、结构等封装到类中，通过类到实例化，来调用具体的功能结构。
 * 2、涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
 * 
 * 二、内存解析的说明
 * 1、引用类型的变量，只可能存储两类值：null或地址值（含变量的类型）
 * 
 * 三、匿名对象的使用
 * 1、理解：我们创建的对象，没有显式的赋给一个变量名，即为匿名对象。
 * 2、特征：匿名对象只能调用一次。
 * 3、使用：
 */

public class InstanceTest {
	public static void main(String[] args) {
		Phone p = new Phone();
		System.out.println(p);
		
		p.sendEmail();
		p.playGame();
		
		//匿名对象
//		new Phone().sendEmail();
//		new Phone().playGame();
		
		new Phone().price = 1999;
		new Phone().showPrice();
		
		//**********************************
		PhoneMall mall = new PhoneMall();
		mall.show(new Phone());
		
	}
}

class PhoneMall{
	public void show(Phone phone) {
		phone.sendEmail();
		phone.playGame();
	}
}

class Phone{
	double price; //价格
	
	public void sendEmail() {
		System.out.println("发送邮件");
	}
	
	public void playGame() {
		System.out.println("玩游戏");
	}
	
	public void showPrice() {
		System.out.println("手机价格为："+price);
	}
}

package com.itguigu.java;
/*
 * 方法的重载（overload）
 * 1、定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
 *		"两同一不同"：同一个类、相同方法
 *					参数列表不同：参数个数不同、参数类型不同
 * 2.举例
 * 		Arrays中的sort、binarySearch
 * 
 * 3.判断是否是重载
 * 		跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系。
 * 
 * 4.在通过对象调用方法时，如何确定某一个指定的方法。
 * 		方法名-->参数列表
 */
public class OverLoadTest {
	
	public static void main(String[] args) {
		OverLoadTest test = new OverLoadTest();
		
		test.getSum("1", 2);
	}
	
	
	public void getSum(int i, int j) {
		System.out.println(1);
	}
	
	public void getSum(double d1, double d2) {
		System.out.println(2);
	}
	
	public void getSum(String s, int i) {
		System.out.println(3);
	}
	
	public void getSum(int i, String s) {
		System.out.println(4);
	}
	
//	public int getSum(int i, int j) {
//		return 0;
//	}

//	public void getSum(int m, int n) {
//		
//	}
	
//	private void getSum(int i, int j) {
//		
//	}
}

package com.atguigu.exer;

public class OverloadExer {
	//如下三个方法构成重载
	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);
	}
	
	//如下三个方法构成重载
	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;
	}
}

package com.itguigu.java;
/*
 * 可变个数形参的方法
 * 1.jdk5.0新增的内容
 * 2.具体使用：
 * 		可变个数形参的格式：数据类型...变量名
 * 		当调用可变个数形参的方法时候，传入的参数个数可以是：0个、1个、2个或多个
 *		可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
 *		可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不够成重载
 *		可变个数形参在方法的形参中，必须声明在末尾
 *		可变个数形参在方法的形参中，最多只能声明一个可变形参。
 */
public class MethodArgsTest {
	public static void main(String[] args) {
		MethodArgsTest test = new MethodArgsTest();
		test.show(12);
		test.show("hello");
		test.show("hello", "world");
	}
	
	public void show(int i) {
		
	}
	
	public void show(String s) {
		System.out.println("show(String)");
	}
	
	public void show(String ... strs) {
		System.out.println("show(String...strs)");
		for(int i=0; i<strs.length;i++) {
			System.out.println(strs[i]);
		}
	}
	
//	public void show(String[] args) {
//		
//	}
	
	public void show(int i, String ... strs) {
		
	}
}

package com.itguigu.java;
/*
 * 关于变量的赋值
 * 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
 * 如果变量是引用数据类型，此时赋值的是变量所保存的地址值。
 */
public class ValueTransferTest {
	public static void main(String[] args) {
		int m = 10;
		int n = m;
		System.out.println(m + "," + n);
		n = 20;
		System.out.println(m + "," + n);
		
		Order o1 = new Order();
		o1.orderId = 1001;
		
		Order o2 = o1; //赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
		
		System.out.println(o1.orderId + "," + o2.orderId);
		
		o2.orderId = 1002;
		
		System.out.println(o1.orderId + "," + o2.orderId);
	}
}


class Order{
	int orderId;
	
}

package com.itguigu.java;
/*
 * 方法形参的传递机制：值传递
 * 1、形参：方法定义时，声明的小括号内的参数。
 *    实参：方法调用时，实际传递给形参的值。
 * 
 * 2、值传递
 * 如果参数是基本数据类型，此时实参赋给形参的是实参的真实存储的数据值。
 * 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
 */
public class ValueTransferTest1 {
	public static void main(String[] args) {
		// 交换两个变量的值的操作
		int m = 10;
		int n = 20;
		System.out.println(m + "," + n);
		
		int temp = m;
		m = n;
		n = temp;
		System.out.println(m + "," + n);
		
		ValueTransferTest1 test = new ValueTransferTest1();
		test.swap(m, n);
		
		System.out.println(m + "," + n);
		
	}
	
	public void swap(int m, int n) {
		int temp = m;
		m = n;
		n = temp;
	}
}

package com.itguigu.java;

public class ValueTransferTest2 {
	public static void main(String[] args) {
		
		Data data = new Data();
		
		data.m = 10;
		data.n = 20;
		
		System.out.println(data.m + "," + data.n);
		
		//交换m和n的值
		int temp = data.m;
		data.m = data.n;
		data.n = temp;
		
		System.out.println(data.m + "," + data.n);
		
		ValueTransferTest2 test = new ValueTransferTest2();
		
		test.swap(data);
		
		System.out.println(data.m + "," + data.n);
	}
	
	public void swap(Data data) {
		int temp = data.m;
		data.m = data.n;
		data.n = temp;
	}
}


class Data{
	int m;
	int n;
}

package com.atguigu.exer;

public class Circle {
	double radius; // 半径
	
	//求圆的面积
	public double findArea() {
		return Math.PI * radius * radius;
	}
}

package com.atguigu.exer;

public class PassObject {
	public static void main(String[] args) {
		PassObject test = new PassObject();
		
		Circle c =new Circle();
		test.printAreas(c, 5);
		
		System.out.println("now radius is " + c.radius);
	}
	public void printAreas(Circle c, int time) {
		System.out.println("Radius\t\tArea");
		
		for(int i=1; i<=time; i++) {
			//设置圆的半径
			c.radius = i;
			System.out.println(c.radius + "\t\t" + c.findArea());
			
		}
		
		c.radius = time + 1;
	}
}

package com.itguigu.java;
/*
 * 递归方法的使用
 * 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);
	}
	
	public int getSum(int n) {
		if(n == 1) {
			return 1;
		}else {
			return n + getSum(n-1);
		}
	}
}