JavaSEDemo05

比眉伴天荒 2021-09-25 05:58 245阅读 0赞

### 文章目录 ###

*  简介
 *  void方法中return语句的使用规范
 *  可变API与不可变API
 *  数据交换与方法传参
 *  为什么不能用返回值类型来判断方法是否重载
 *  可变参数
 *  普通方法与构造方法同名
 *  构造方法调用同名构造方法
 *  this与链式编程
 *  this用于传递本对象引用
 *  java的访问修饰符
 *  构造方法的特点
 *  方法签名
 *  方法递归及练习

# 简介 #

*  本文是2021/03/24晚上整理的笔记
 *  赘述可能有点多，还请各位朋友耐心阅读
 *  本人的内容和答案不一定是最好最正确的，欢迎各位朋友评论区指正改进。

# void方法中return语句的使用规范 #

*  void方法一般是不写return语句的，当然了也可以写。
 *  void方法中return语句的使用规范:(1)return后面什么也不跟;(2)return必须是最后一句。
 *  (1)如果我们在return语句后写了数值
 *  代码示例:

public static void method(){ 
            return null;
        }

*  图  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center]
 *  错误解释 无法从返回值类型为void方法中返回一个值
 *  (2)如果我们在return语句后写了语句

public static void method(){ 
            return;
            System.out.println();
        }

*  图  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center 1]
 *  解释:无法到达的语句；

# 可变API与不可变API #

*  可变API:在给定的既有内存上进行操作的API
 *  不可变API:执行时需要分配新的内存才能执行的API，new关键字创建对象时就是不可变API，它为对象分配新的空间。
 *  其中，最常见的，Java的String类型没有任何的可变API，因为你对字符串的任何改变都只是创建了一个新的字符串对象。

# 数据交换与方法传参 #

public class Test { 
        public static void main(String[] args) { 
            int a = 10;
            int b = 20;
            swap(a,b);
            System.out.println("main方法中a:"+a+" b:"+b);
        }
        public static void swap(int a,int b){ 
            int temp = a;
            a = b;
            b = temp;
            System.out.println("swap方法中a:"+a+" b:"+b);
        }
    }

程序运行结果

swap方法中a:20 b:10
    main方法中a:10 b:20

*  为什么main方法中的a和b值没有发生交换呢？
 *  因为Java使用的是值传递,值传递是将传入方法的实参拷贝一份交给形参，并不会对原实参产生影响。
 *  关于值传递和引用传递我在另一篇博客里有写，感兴趣的可以点击跳转  
    [2021/03/21Java中向方法中传入参数时遇到的问题][2021_03_21Java]
 *  请看内存图  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center 2]
 *  那么如何交换数据呢？我们可以使用类对数据进行包装(注意和包装类不是一个东西)
 *  注意:本处代码中的User类和Test分别在两个java文件中

//定义一个User类
    public class User { 
        int a = 10;
        int b = 20;
    }
    ---------------------------------------------------
    //测试类
    public class Test { 
        public static void main(String[] args) { 
            User user = new User();
            swap(user);
            System.out.println("main方法中a:"+user.a+" b:"+user.b);
        }
        public static void swap(User user){ 
            int temp = user.a;
            user.a = user.b;
            user.b = temp;
            System.out.println("swap方法中a:"+user.a+" b:"+user.b);
        }
    }

程序运行结果

swap方法中a:20 b:10
    main方法中a:20 b:10

*  为什么用类对数据包装完以后，就可以实现数据交换了呢？
 *  因为我们创建一个对象的时候，Java会为对象在堆中分配内存，我们通过对象访问堆中存储的成员变量，swap方法传入的参数是对象在堆中的地址，交换的数据也是堆中的变量。
 *  请看内存图  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center 3]

# 为什么不能用返回值类型来判断方法是否重载 #

public void add(double a,double b){ 
    
        }
        public double add(double a,double b){ 
            double sum = a + b;
            return sum;
        }

*  假如我们定义了两个方法名称相同，参数列表相同，返回值类型不同的方法。(如上代码是错误的)
 *  如果我们想要调用有返回值的方法，编译器却为我们调用了没有返回值类型的方法。那岂不是闹了笑话？
 *  编译器傻傻分不清楚

# 可变参数 #

public static void show(int a,int...b){ 
        }

*  如上代码:int…b就是一个可变参数
 *  无论你之后传入多少参数都可以接收
 *  使用规范:
 *  (1)可变参数只能有一个
 *  (2)可变参数必须写在参数列表的最后一个
 *  (3)书写格式:数据类型…形参名称 三个点和前后的数据类型和形参名称中间有没有空格都可以
 *  (4)可变参数与数组类似，也有长度:参数名称.length

public class Test { 
        public static void main(String[] args) { 
            System.out.println(show(1,2,3,4,5,6,7));
        }
        public static int show(int...a){ 
             return a.length;
        }
    }

程序运行结果

# 普通方法与构造方法同名 #

*  在Java中允许普通方法与构造方法同名，但是不推荐这么写

public class User { 
        String name;
        int age;
        //无参构造方法
        public User() { 
            System.out.println("无参构造方法被调用");
        }
        //全参构造方法
        public User(String name, int age) { 
            this.name = name;
            this.age = age;
            System.out.println("全参构造方法被调用");
        }
        //普通方法
        void User(){ 
            System.out.println("普通方法被调用");
        }
    }
    ---------------------------------------------------
    public class Test { 
        public static void main(String[] args) { 
            User u1 = new User();
            User u2 = new User("张三",20);
        }
    }

程序运行结果

无参构造方法被调用
    全参构造方法被调用

*  我们创建对象时只会调用构造方法，若想调用普通方法，创建好对象后，通过对象名.方法名来调用。

# 构造方法调用同名构造方法 #

public class User { 
        int number;
        int age;
        //全参构造方法
        public User(int number, int age) { 
            this.number = number;
            this.age = age;
        }
        //无参构造方法
        public User() { 
            this(0,0);
        }
    }

*  如上代码，无参构造方法中调用了全参构造方法，实参为0和0
 *  构造方法调用同名构造方法的使用规范:this语句必须为第一句
 *  否则会出现以下错误:  
    ![在这里插入图片描述][20210324205629265.png_pic_center]  
    错误解释:调用this()必须时构造方法中第一条语句。

# this与链式编程 #

*  我们用一段代码来演示链式编程的效果

//苹果类
    public class Apple { 
        int apple = 0;
        //返回值类型为本类Apple类,返回this,即返回调用此方法的对象，调用时可以连续调用。
        public Apple addApple(){ 
               apple++;
               return this;
        }
        //打印苹果的数量
        public void print(){ 
            System.out.println("共有苹果:"+apple+"个");
        }
    }
    -----------------------------------
    //测试类
    public class Test { 
        public static void main(String[] args) { 
            Apple apple = new Apple();
            //一共调用了3次addApple方法,apple增加了3次
            apple.addApple().addApple().addApple().print();
        }
    }

程序运行结果

共有苹果:3个

# this用于传递本对象引用 #

/* 定义父亲类和儿子类,父亲可以采摘苹果,儿子也可以采摘苹果 */
    public class Son { 
           //定义苹果数量
          int apple;
          //定义一个儿子类中的摘苹果的方法
          public void pickApple(){ 
          //此方法中创建了一个Father类对象
             Father father = new Father();
             //将调用此方法的对象，传给父亲类中的摘苹果的方法
             father.pickApple(this);
          }
    
    
    }
    --------------------------------
    public class Father { 
           //定义一个父亲类中的摘苹果的方法,参数为Son类型的对象
        public void pickApple(Son son){ 
              son.apple = 50;
        }
        //main方法
        public static void main(String[] args) { 
            Son son = new Son();
            son.pickApple();
            System.out.println(son.apple);
        }
    }

程序运行结果

看上去比较乱，我们来看一下内存图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center 4]

# java的访问修饰符 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center 5]

# 构造方法的特点 #

*  语法:public 类名（）\{  
    \}
 *  构造方法没有返回值

# 方法签名 #

*  由方法名称和参数列表组成。方法签名常用于方法重载和重写。

# 方法递归及练习 #

*  方法自己调用自己
 *  方法递归要有一个明确的方向，不然程序会一直进行下去，形成死循环
 *  练习题目：  
    有一只猴子摘了一大堆桃子吃，它按照这样的规律吃桃子：第一天吃一半多一个，第二天吃第一天剩余的一半多一个，第三天吃第二天剩余的一半多一个…以此类推，当第七天时，恰好只剩下一个桃子。求猴子一共摘了多少个桃子？
 *  解题思路:我们可以用数学思想来解决这个问题
 *  设一个F(n),F为桃子数量 n为天数
 *  我们知道F(7)=1，第七天是第六天吃剩下的，第六天吃了一半多一个
 *  即F(7)=F(6)-F(6)/2 -1 ;
 *  换算一下，就得出 F(6) = \[F(7)+1\] x 2
 *  继续可以得出 F(5) = \[F(6)+1\] X 2
 *  F(4) = \[F(5)+1\] X 2
 *  规律就是 F(n) = \[F(n+1) + 1\] X 2
 *  同时递归的终止条件为F(7) =1
 *  代码实现:

public class Monkey { 
        public static void main(String[] args) { 
            System.out.println("最初有"+F(1)+"个桃子");
        }
        public static int F(int n){ 
                   if(n ==7){ 
                       return 1;
                   }else{ 
                       return (F(n+1)+1)*2;
                   }
        }
    }

程序运行结果

最初有190个桃子

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center]: /images/20210923/4113506fa4134df28dc9753cc9426a7b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20210923/f41f990bb8ac4fcba42d25dc0066afc5.png
[2021_03_21Java]: https://blog.csdn.net/hypertext123/article/details/115067730
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20210923/fe54393c30f84d3ba9dff70614538483.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20210923/685bab58bfbf4a54aa69449386c33a21.png
[20210324205629265.png_pic_center]: /images/20210923/36c57025cef849b49d7708f7ee8aec2d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20210923/3c336196e992420797a4c121e95ff988.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20210923/f46a6c227e174e9dbd7992f6708e2b0b.png