DAY 10

day 10

package shangGuiGu.day10;

public class demo01 {
    public static void main(String[] args) {
        phone p=new phone();
        System.out.println(p);//地址shangGuiGu.day10.phone@49e4cb85
        p.sendEmail();
        p.playGame();
        //匿名
        //理解：创建的对象没有显示的赋给一个变量名。即为匿名对象
        //特征：匿名对象只能调用一次
        //使用
        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 Phone1){
        Phone1.sendEmail();
        Phone1.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 shangGuiGu.day10;

public class demo02 {
    //求数组的最大值
    public int getMax(int[] arr) {
int maxvalue=arr[0];
for(int i=0;i<arr.length;i++){
    if(maxvalue<arr[i]){
        maxvalue=arr[i];
    }
}
        return maxvalue;
    }

    //求数组的最小值
    public int getMin(int[] arr) {

int minvalue=arr[0];
for(int i=0;i< arr.length;i++){
    if(minvalue>arr[i]){
        minvalue=arr[i];
    }
}
        return minvalue;
    }
    //求数组的总和
    public int getSum(int[] arr) {
int sum=0;
for(int i=0;i< arr.length;i++){
    sum+=arr[i];
}
        return sum;
    }
    //求数组的平均值
    public int getAvg(int[] arr) {

        return getSum(arr)/arr.length;
    }
    //翻转数组
    public void reverse(int[] arr) {

for(int i=0;i<arr.length/2;i++){
    int temp=arr[i];
    arr[i]=arr[arr.length-i-1];
    arr[arr.length-i-1]=temp;

}
         }
    //复制数组
    public int[] copy(int[] arr) {
int[] arr1=new int[arr.length];
for(int i=0;i<arr1.length;i++){
    arr1[i]=arr[i];
}
        return arr1;
    }
    //数组排序
    public void sort(int[] arr) {
    for(int i=0;i<arr.length-1;i++){
        for(int j=0;j<arr.length-i-1;j++){
            if(arr[j]>arr[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< arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
    }
    //查找指定元素
    public int getIndex (int[] arr,int dest) {
        for(int i=0;i<arr.length;i++){
            if(dest==arr[i]){
                return i;
            }
        }
    return -1;//返回一个负数表示没有找到
    }

}

package shangGuiGu.day10;

public class demo03 {
    public static void main(String[] args) {
        demo02 util=new demo02();
        int[] arr1=new int[]{1,2,3,44,12,15,87};
        int max=util.getMax(arr1);
        System.out.println("最大值为："+max);
        System.out.println("排序前：");
        util.print(arr1);
        util.sort(arr1);
        System.out.println();
        System.out.println("排序后：");
        util.print(arr1);
        System.out.println();
        System.out.println("查找：");
        int index=util.getIndex(arr1,5);
        System.out.println(index);
    }
}

方法的重载overload

在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或参数类型不同即可。

“两同一不同”：同一个类、相同方法名

参数列表不同：参数个数不同，参数类型不同

判断是否是重载：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！

package shangGuiGu.day10;

public class demo04 {
    //如下的四个方法构成了重载
    public static void main(String[] args) {
        demo04 test=new demo04();
        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");
    }
}

可变个数形参

格式：数据类型…变量名

当调用可变个数形参的方法时，传入的参数个数可以是：0,1,2,3，。。。

可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载

可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。即二者不能共存

可变个数形参在方法的形参中，必须声明在末尾，且最多只能声明一个可变形参

package shangGuiGu.day10;
//可变个数形参
public class demo05 {
    public static void main(String[] args) {
        demo05 test=new demo05();
        test.show(12);
        test.show("hello","world");
        test.show();
    }
    public void show(int i){

    }
    public void show(String s){
        System.out.println("show(String)");
    }
    public void show(String ... strs){
        for(int i=0;i<strs.length;i++){
        System.out.println(strs[i]);
    }

} public void show(int q,String ... strs){
        for(int i=0;i<strs.length;i++){
            System.out.println(strs[i]);
        }
}}

package shangGuiGu.day10;

//关于变量的赋值
public class demo06 {
    public static void main(String[] args) {
        //对于基本数据类型，赋值就是把值赋给他
        int m=10;
        int n=m;
        System.out.println("m="+m+",n="+n);//m=10,n=10
        n=20;
        System.out.println("m="+m+",n="+n);//m=10,n=20
        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;
}

package shangGuiGu.day10;
/*
//方法的形参的传递机制：值传递
1.形参：方法定义时，声明的小括号内的参数
  实参：方法调用时，实际传递给形参的数据

2.值传递机制：
如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值
如果参数是引用数据类型，此时实参赋给形参的是实参存储的数据的地址值
*/
public class demo07 {
    public static void main(String[] args) {

        int m1=10;
        int n1=20;

int[]aarr=new int[]{1,2,5,4};
        demo07 test=new demo07();
        test.swap(m1,n1);//m=20,n=10
        System.out.println("m="+m1+",n="+n1);//m=10,n=20
        //交换两个变量的值的操作
        for(int i=0;i<aarr.length-1;i++) {
            for (int j = 0; j < aarr.length - 1 - i; j++) {
                if (aarr[j] > aarr[j + 1]) {
                    test.swap(aarr, j, j + 1);
                }
            }
        }
        for(int i=0;i<aarr.length;i++) {
            System.out.print(aarr[i]);
        }
    }
    public void swap(int m,int n){
        int temp=m;
        m=n;
        n=temp;
        System.out.println("m="+m+",n="+n);
    }
    public void swap(int[]aarr,int i,int j){
        int temp=aarr[i];
        aarr[i]=aarr[j];
        aarr[j]=temp;
    }
}

package shangGuiGu.day10;

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

    }

}

递归方法

一个方法体内调用它本身

package shangGuiGu.day10;

public class demo09 {
    public static void main(String[] args) {
        //计算1-100之间所有自然数的和
        int sum=0;
        for(int i=1;i<=100;i++)
        {
        sum+=i;
        }
        System.out.println(sum);
        demo09 test=new demo09();
        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);
        }
    }
}

封装

高内聚：类的内部数据操作细节自己完成，不允许外部干涉

低耦合：仅对外暴露少量的方法用于使用

隐藏对象内部的复杂性，只对外公开简单的接口。即把该隐藏的的隐藏起来，把该暴露的暴露出来

package shangGuiGu.day10;

public class demo10 {
    public static void main(String[] args) {
        animal a=new animal();
        a.name="大黄";
        a.age=1;
        a.setlegs(-4);
        a.show();
    }
}
class animal{
    String name;
    int age;
    private int legs;
    public void setlegs(int l){
        if(l>=0&&l%2==0){
            legs=l;
        }else{
            legs=0;
        }
    }
    public void eat(){
        System.out.println("动物进食");
    }

    public void show() {
        System.out.println("name="+name+",age="+age+",legs="+legs);
    }

}