一，怎样理解万事万物皆对象
1，在Java语言范畴中，我们都将功能、结构封装到类中，通过类的实例化，来调用具体的功能结构 ；2，涉及到Java语言与前端HTMl、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。 匿名对象的使用
package com.atguigu.java;
public class InstanceTest {
public static void main(String[] args) {
Phone p=new Phone();
System.out.println(p); //com.atguigu.java.Phone@15db9742 ---是一个地址值
p.sendEmail();
p.playGame();
new Phone().price=1999;
new Phone().showPrice(); //double型price默认初始化值为0.0（一个新的Phone对象）
System.out.println("**********");
//想要调用show()方法，则需要造一个方法所在类的对象
PhoneMall mall=new PhoneMall();
//匿名对象的常用情景
mall.show(new Phone()); //相当于把这个匿名的对象赋给了形参phone
}
}
class PhoneMall{
public void show(Phone phone){ //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);
}
}
数组工具类的封装(分成两个文件演示)
①ArrayUtil.java:
package com.atguigu.java;
public class ArrayUtil {
//求最大最小平均总和，需要知道求谁的，所以都要有形参
//求数组的最大值
public int getMax(int[] arr){
int maxValue=arr[0];
for(int i=0;iarr[i]){
minValue=arr[i];
}
}
return minValue;
}
//求数组的总和
public int getSum(int[] arr){
int sum=0;
for(int i=0;iarr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
//遍历数组
public void print(int[] arr){
for(int i=0;i
测试–ArrayUtilTest.java：
package com.atguigu.java;
public class ArrayUtilTset {
public static void main(String[] args) {
ArrayUtil util=new ArrayUtil();
int[] arr=new int[]{32,34,32,5,3,54,654,-98,0,-53,5};
int max=util.getMax(arr);
System.out.println("最大值为："+max);
int min=util.getMin(arr);
System.out.println("最小值为："+min);
int sum=util.getSum(arr);
System.out.println("总和为："+sum);
int avg=util.getAvg(arr);
System.out.println("平均值为："+avg);
//排序
System.out.println("排序前：");
util.print(arr); //遍历排序前
System.out.println(); //换行比较
util.sort(arr); //排下序
System.out.println("排序后：");
util.print(arr); //遍历排序后
//查找
System.out.println("查找");
int index = util.getIndex(arr, 5);
if(index>=0){
System.out.println("找到了，索引地址为："+index); //4找到的是经过上面排序操作后的索引值
}else{
System.out.println("找不到");
}
}
}
方法的重载（overload）
重载的概念:
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
简而言之，满足“两同一不同” 即为重载。
两同：同一个类，同一个方法名
一不同：参数列表不同（包括参数个数不同，参数类型不同）
如下图，Arrays类中重载的多个binarySearch()方法、sort()方法：
如我们写的ArrayUtil提供了很多功能操作（反转、复制），但只能对int型数组进行。若对String型则需要进行方法的重载。
如下：我们对ArrayUtil中数组的反转操作进行方法的重载：
则以上两个同名方法构成了重载。
此时，当我们在ArrayUtilTest.java中通过util对象调用reverse()方法时会出现选择提示，我们根据参数进行选择：
package com.atguigu.java1;
public class OverLoadTest {
public static void main(String[] args) {
}
//如下的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 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 static void main(String[] args) {
OverloadExer test =new OverloadExer();
test.mOL(5);
test.mOL(5, 6);
test.mOL("dingdingdang");
}
//如下三个方法构成重载
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);
}
}
package com.atguigu.exer;
public class OverloadExer {
public static void main(String[] args) {
OverloadExer test =new OverloadExer();
int value1=test.max(3, 7);
System.out.println(value1);
double value2=test.max(10.6, 5.2);
System.out.println(value2);
double value3=test.max(0.03, 0.05, 1.15);
System.out.println(value3);
}
//如下三个方法构成重载
public int max(int i,int j){
return (i>j)?i:j; //一步到位，若用if语句太繁琐
}
public double max(double d1,double d2){
return (d1>d2)?d1:d2; //一步到位，若用if语句太繁琐
}
public double max(double d1,double d2,double d3){
double max=(d1>d2)?d1:d2; //一步到位，若用if语句太繁琐
return (max>d3)?max:d3;
}
}
可变个数的形参（jdk5.0新增内容）
JavaSE 5.0 中提供了Varargs(variable number of arguments)机制， 允许直接定义能和多个实参相匹配的形参 。从而，可以用一种更简单的方式，来传递个数可变的实参。
package com.atguigu.java1;
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest test=new MethodArgsTest();
test.show(12);
test.show("hello"); //输出show(string)
System.out.println("******");
test.show("hello","world");
test.show("hello","world","didida");
}
public void show(int i){
System.out.println(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
注意：
①jdk 5.0 认为public void show(String[] strs){}与public void show(String … strs){}无区别，所以二者不能构成重载。
即：可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载（二者不能共存）。
②可变个数的形参在方法的形参中，必须声明在末尾，且最多只能声明一个可变形参（可变个数形参不知道要匹配多少个，所以不可以在前面声明，只能放最后且也因此只能声明一个）。
eg:public void show( int i ,String …arrs){ } -----正确书写格式
方法参数的值传递机制
首先我们知道：
关于对象的赋值机制：
如果变量是基本数据类型，此时赋的值是变量所保存的数据值；
如果变量是引用数据类型，此时赋的值是变量所保存的数据的地址值。
类似于对象的赋值，方法参数的值传递机制如下：
如果参数是基本数据类型，此时实参赋给形参的是实参中真实存储的数据值；
如果参数是引用数据类型，此时实参赋给形参的是实际存储数据的地址值。
分析问题：
package com.atguigu.java1;
public class ValueTransferTest1 {
public static void main(String[] args) {
int m=10;
int n=20;
System.out.println("m="+m+",n="+n);
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;
}
}
我们发现并没有显示m和n交换成功。原因如下：
再如：
运行ArrayUtilTest.java发现排序无效:
原因：
上述定义临时变量写法确实交换了arr[j]和arr[j+1]。但通过 swap(arr[j],arr[j+1]); 若调用如下swap()方法，实际上只是把两个实参arr[j]和arr[j+1]传给了i和j，只交换了i和j的值，arr[j]和arr[j+1]还是原来的值。
所以说：如果参数是基本数据类型，此时实参赋给形参的是实参中真实存储的数据值。
想实现交换效果可以传入引用数据类型
对ArrayUtil进行修改：
排序成功
相关解释：
package com.atguigu.java1;
public class ValueTransferTest2 {
public static void main(String[] args) {
Data data =new Data();
data.m=10;
data.n=20;
System.out.println("m="+data.m+",n="+data.n);
ValueTransferTest2 test=new ValueTransferTest2();
test.swap(data);
System.out.println("m="+data.m+",n="+data.n);
}
public void swap(Data data){ //此处的形参为引用数据类型，名为data的Data型数据
//交换m、n值
int temp=data.m;
data.m=data.n;
data.n=temp;
}
}
class Data{
int m;
int n;
}
所以说：如果参数是引用数据类型，此时实参赋给形参的是实际存储数据的地址值
练习：
最后输出的是：
本题内存解析：
做貌似简单的题目（擦亮眼睛）：
若用此法，我们会发现，第一位元素除了12后变为1，其余元素除以1，原样输出。
正确写法（一）：
倒着除，巧妙解决问题。
正确写法（二）：
额外开辟空间temp。
练习：
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("RadiusttArea");
//设置圆的半径
for(int i=1;i<=time;i++){
c.radius=i;
System.out.println(c.radius+"tt"+c.findArea());
}
c.radius=time+1;
}
}
