- 理解“万事万物皆对象”
- 匿名对象的使用
- 方法的重载（over load）
- 可变个数形参的方法
- 关于变量的赋值
- 值传递
- 递归方法
一：理解“万事万物皆对象”
1、在Java语音范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
>Scanner，String
>文件：File
>网络资源：URL
2、涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象
二：内存解析的说明
1、引用类型的变量，只能存储两类值：null 或 地址值（包含变量类型）
三、匿名对象的使用
1、理解：我们创建的对象，没有显示的赋给一个变量。即为匿名对象。
2、特征：匿名对象只能调用一次。
3、使用：如下
Phone p = new Phone();
System.out.println(p);
p.sendEmail();
p.playGame();
//匿名对象
// new Phone().sendEmail();
// new Phone().playGame();
new Phone().price = 1999;
new Phone().getPrice();//0.0
PhoneMall mall = new PhoneMall();
// mall.show(p);
//匿名对象的使用
mall.show(new Phone());
//----------------------------- 类 -----------------------------------
class Phone{
double price;
public void sendEmail(){
System.out.println("发送邮件");
}
public void playGame(){
System.out.println("玩游戏");
}
public void getPrice(){
System.out.println(price);
}
}
class PhoneMall{
public void show(Phone phone){
phone.sendEmail();
phone.playGame();
}
}
方法的重载（over load）
1、定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或参数类型不同即可。
“两同一不同”：同一个类、方法名
参数列表不同：参数个数不同、参数类型不同
2、举例：
Arrays类中重载的方法有sort（）/binarySearch（）
3、判断是否是重载：
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
4、在通过对象调用方法时，如何确定某一个指定的方法：
方法名 —> 参数列表
overload test = new overload();
test.getSum(1,2);//1，如果注释掉参数是int类型的方法，就会自动类型提升到其他重载类型。
test.getSum(1.0,2.0);//2
test.getSum("1",2);//3
test.getSum(1,"2");//4
//------------------------------- 类 --------------------------------
class overload{
//如下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 s1, 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){
//
// }
public int getSum(double d1, int i){
return 0;
}
}
可变个数形参的方法
1、jdk5.0新增的内容
2、具体使用
2.1 可变个数形参的格式：数据类型 … 变量名
2.2 当调用可变个数形参的方法时，传入的参数个数可以说0个，1个，2个…
2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
2.5 可变个数形参在方法的形参中，必须声明在末尾（如果把可变参数放在中间或者前面的话，如果与可变参数
相邻的参数和他的类型相同，计算机就无法准确分析那个是固定参数，哪些是可变参数，计算过程中肯定会出现问题，
所以Java规定可变参数要放在末尾）
☆：以String[] str的方式思考，传入一个值，那这个数组长度就是1，两个值，数组长度就是2 ....
如果放在第一个，那么所有的String类型数据都会被装入这个形参的数组中。如果可变形参后面的形参也是String类型形参的话就无法接收到。
因为这个考虑，java规定可变形参必须放在形参列表的最后。
通俗的讲：可变形参可以接收无限个数的形参（类型相同的情况下），所以只能让可变形参接收剩下的参数，而不能一开始就让它去接收形参。
2.6 可变个数在方法形参中，最多只能声明一个可变形参。
☆可变形参 (String … str)与 (String[] str)的区别
1、(String … str)可以直接传入数组引用，或(“a”,“b”,“c”)一个个传，或(new String[]{“a”,“b”,“c”})
这三种方式来传递值。但是如果形参列表有多个形参，可变形参只能放在最后。
2、(String[] str)只能直接传递数组引用，或(new String[]{“a”,“b”,“c”})
在形参列表中没有位置限制。
MethodArgsTest test1 = new MethodArgsTest();
test1.show(12);
test1.show("hello");//优先匹配进准的方法
//可变形参的方法可以使用这两种模式
test1.show("hello","world");//而数组形参不能用这一种
test1.show(new String[]{"hello","world"});
//--------------------------- 类 --------------------------------
class MethodArgsTest{
public void show(int i){
System.out.println(i);
}
public void show(String s){
System.out.println("X");
}
public void show(String ... strs){
for (int i = 0; i <strs.length ; i++) { //strs就可以当做是一个String[]类型的数组。
System.out.println(strs[i]);
}
}
// public void show(String[] strs){
//
// }
//可变参数（Vararg）必须是列表中的最后一个参数
// public void show(String ... strs,int i){
//
// }
}
关于变量的赋值
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
//基本数据类型
int m = 10;
int n = m;
System.out.println(m+","+n);//10,10
n = 20;
System.out.println(m+","+n);//10,20
//引用数据类型
Order o1 = new Order();
Order o2 = o1; //赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
System.out.println(o1.orderId+","+o2.orderId);//1001,1001
o2.orderId = 1002;
System.out.println(o1.orderId+","+o2.orderId);//1001,1002
//------------------------------ 类 --------------------------------
class Order{
int orderId = 1001;
}
方法的形参的传递机制：值传递
1、形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据
2、值传递机制：
如果参数是基本数据类型，此时实参赋给形参的是，实参真实存储的数据值。
如果参数是引用数据类型，此时实参赋给形参的是，实参存储数据的地址值。
int[] arr = new int[]{1,4,-4,6,8,34,89,0};
for (int i = 0; i <arr.length ; i++) {
for (int j = 0; j <arr.length-1-i ; j++) {
if(arr[j]>arr[j+1]){
swap(arr,j);
}
}
}
System.out.println(Arrays.toString(arr));
//-------------------------- 方法 -------------------------------
//值传递swap方法
//错误的：交换数组中指定两个元素的位置。
// public void swap(int i, int j){
// int temp = i;
// i = j;
// j = temp;
//
// }
//正确的：
public static void swap(int[] arr,int j){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
递归方法的使用（了解）
1、递归方法：一个方法体内调用它自己
2、方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制。
3、递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
//例1：计算1-100之间所有自然数的和
//方式1：循环
int j = 0;
for (int i = 1; i <101 ; i++) {
j += i;
}
System.out.println(j);//5050
System.out.println(getSum(100));//5050
//------------------------------ 方法 ----------------------------
//getSum()方法
public static int getSum(int n){
if(n==1){
return 1;
}else{
return n+getSum(n-1);
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）