day10
理解"万事万物皆对象"
再谈方法:
匿名对象只能调用一次
new Phone().sendEmail();
new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();//0.0
应用场景:
PhoneMall mall = new PhoneMall();
//匿名对象的使用
mall.show(new Phone());
其中
class PhoneMall{
public void show(Phone phone){
Phone.sendEmail();
Phone.playGeame();
}
}
4.6.1方法的重载
/*
* 关于变量的赋值
*
* 如果变量是基本数据类型,此时赋值的时变量所保存的数据值。
* 如果变量是引用数据类型,此时赋值的时变量所保存的数据的地址值。
*/
public class ValueTransferTest {
public static void main(String[] args) {
int m = 10;
int n = m;
System.out.println("m = " + m + "n = " + n);
n = 20;
System.out.println("m =" + m + ", n = " + n);
System.out.println("*************引用数据类型*************");
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;//赋值以后,o1和o2的地址值相同,都指向
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
}
}
class Order{
int orderId;
}
方法的重载(overload) loading...:在同一个类中，允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。
1.定义:在同一类中,允许存在一个以上同名方法,只要它们的参数个数或者参数类型不同即可。
"两同一不同:同一类"
2.举例
Arrays类中重载sort() / binarySearch()
3.判断是否是重载:
跟方法的权限修饰符、返回值类型、形参变量名、方法体都美好还有关系!
4. 在通过对象调用方法是,如何确定某一个指定的方法;
方法名 ---> 参数列表
public class OverLoadTest {
//如下的4个方法构成了重载
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 void getSum(int i,int j){
// return 0;
// }
// public void getSum(int m,int n){
//
//}
// public void getSum(int i,int j){
//
//}
}
public class OverloadExer {
public void mOL(int i){
System.out.println(i * i);
}
public void mOL(String s){
System.out.println(i * j);
}
}
如何判断是否构成方法的重载?
严格按照定义:两同一不同
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系!
如何确定类中某一个方法的调用:
方法名 ---> 参数列表
拓展知识:方法的重载与重写的区别?
重载:两同一不同
重写:将该方法重写
throws/throw
String\StringBuffer\StringBuilder
Collection\Collections
final\finally\finalize
...
抽象类、接口
sleep()/wait()
4.6.2可变形参的方法
可变形参的方法:
/*
* 可变个数形参
* JavaSE5.0中提供了Varargs(variable number of arguments)机制,
* 允许直接定义能和多个实参相匹配的形参,从而,可以用一种更简单的方式,来传递个数可
* 变的实参。
*
* 1.Jdk 5.0新增的内容
* 2.具体使用
* 2.1 可变个数形参的格式,数据类型...变量名
* 2.2 当调用可变个数形参的方法式,传入的参数个数可以是 0、1、2
* 2.3 可变个数形参的方法与本类中方法
* 2.4 可变个数形参的方法与本类中方法名相同,形参
* 2.5 可变个数形参在方法的形参中,必须声明在末尾
* 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。
*/
// public void show(String[] strs) {
//
//}
//此为可变个数形参的使用规则
public void show(String ... strs){}
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[] strs){
//
//}
调用时:
test.show("hello");
test.show("hello",world");
test.show();
test.show(new String[]{"AA","BB","CC"});
4.6.3方法参数的值传递机制
package com.atguigu.java1;
/*
* 关于变量的赋值
*
* 如果变量是基本数据类型,此时赋值的时变量所保存的数据值。
* 如果变量是引用数据类型,此时赋值的时变量所保存的数据的地址值。
*/
public class ValueTransferTest {
public static void main(String[] args) {
int m = 10;
int n = m;
System.out.println("m = " + m + "n = " + n);
n = 20;
System.out.println("m =" + m + ", n = " + n);
System.out.println("*************引用数据类型*************");
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;//赋值以后,o1和o2的地址值相同,都指向
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
}
}
class Order{
int orderId;
}
规则:如果变量是基本数据类型,此时赋值的时变量所保存的数据值。
如果变量是引用数据类型,此时赋值的时变量所保存的数据的地址值。
/*
* 方法的形参的传递机制:值传递
*
* 1.形参:方法定义时,声明的小括号内的参数
* 实参:方法调用时,实际传递给形参的数据
*
* 2.值传递机制:
* 如果参数是基本数据类型,此时实参赋给形参的是,实参真实存储的数据值。
*
*
*/
public class ValueTransferTest1 {
public static void main(String[] args) {
int m = 10;
int n = 20;
System.out.println("m = "+ m + ",n = " + n);
//交换两个变量的值的操作
//int temp = m;
//m = n;
//n = temp;
ValueTransferTest1 test = new ValueTransferTest1();
test.swap(m, n);
System.out.println("m = " + m + ",n = " + n);
}
//交换数组中指定两个位置
public void swap(int m,int n) {
int temp = m;
m = n;
n = temp;
}
}
/*
示例代码:
方法参数的值传递机制(*):
* 如果参数时基本数据类型,此时实参赋给形参的是实参真实存储的数据值。
* 如果参数时引用数据类型,此时实参赋给形参的时实参存储数据的地址值。
//交换数组中指定两个位置元素的值
public class ValueTransferTest {
public static void main(String[] args) {
String s1 = "hello";
ValueTransferTest test = new ValueTransferTest();
test.change(s1);//hi~~
}
public void change(String s){
s = "hi~~";
}
}
将变量进行了赋值
将对象指向了同一地址
public static void main(String[] args){
Data data = new Data();
data.m = 10;
data.n = 20;
v.swap(data);
System.out.println(data.m,data.n);
}
swap(arr[],arr[i],arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
class Data{
int m;
int n;
}
*/
main(){
int m = 10;
int n = 20;
v.swap(m,n);
System.out.println(m,n);
}
swap(int m,int n){
int temp = m;
m = n;
n = temp;
System.out.println(m,n);
}
/*
* 递归方法的使用(了解)
* 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);
}
public int getSum(int n) {
if(n == 1) {
return 1;
}else {
return n + getSum(n - 1);
}
}
//例二:计算1-100之间所有自然数的乘积:n!
public int getSum1(int n) {
if(n == 1) {
return 1;
}else {
return n * getSum(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);
}
}
//例4:菲波那契数列
//例5:汉诺塔问题
//例6:快排
//递归算法让我理解深刻,虽然很复杂但是可以用最简单的算法来解决所有问题。
}
什么是方法的重载?
"两同一不同":同一个类、相同方法名;参数列表不同。
如何调用确定的方法:方法名 -> 参数列表
2.说明Java方法中的参数传递机制的具体体现?
基本数据类型:数据值
引用数据类型:地址值()
Person p1 = new Person();
User u1 = p1;//编译错误 (逆向思维、反证法)
u1.eat() u1.age
3.成员变量和局部变量在声明的位置上、是否有默认初始化值上、是否能有权限修饰符上、内存分配的位置上有何不同？
4.谈谈return关键字的使用、
1.结束方法
2.针对于有返回值的方法,return + 返回数据
5.提供如下代码的内存解析
pubilc class TransferTest3 {
public static void main(String[] args) {
TransferTest3 test = new TransferTest3();
test.first();
}
pubilc void first() {
int i = 5;
Value v = new Value();
v.i = 25;
second(v,i);
System.out.println(Value v,int 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);
}
}
//结果是15和20。
1.内存结构:栈(局部变量)、堆(new出来的结构:对象、数组)
2.变量:成员变量 vs 局部变量 (方法内、方法形参、构造器、代码块内)
难点重重需要理解,后期继续学习后我会继续完善更新
浙公网安备 33010602011771号