Java基础(二)

Pragma mark — NO.1 方法递归

一个方法体内调用它自身，被称为方法递归。方法递归包含了一种隐式循环，它会重复执行某段代码，但这种重复执行无须循环控制。

public class JavaExample {
    public static void main(String[] args){
      //输出f(10)的结果
       int result = Example.fn(10);
        System.out.println(result);
     }

       public static class Example{
        //f0 = 1 ,f1 = 4. f(n + 2) = 2*f(n+1) + f(n),我们用递归解决
      public  static  int fn(int n){
              if (n == 0){
                 return 1;
               }else if (n == 1){
                   return 4;
               }else{
                   return  2 * fn(n - 1) + fn(n -2);
               }
           }
 }
#注:递归一定要向已知的方向递归，就是递归到最后的值一定是已知的。我们例子中由于递归回去，f0和f1的值是已知的，所以可以算出f(10)的值。

Pragma mark — NO.2 方法重载

Java允许同一个类里定义多个同名方法，只要形参列表不同就行。如果同一个类中包含了两个及以上方法的方法名相同，但形参列表不同，则被称为方法重载。
Java中确定一个方法需要三个要素:
1.调用者
2.方法名
3.形参列表

public class JavaExample {
    public static void main(String[] args){
  Example.test();
     String result = Example.test("你爱我吗？");
        System.out.println(result);
  }

       public static class Example{

        public  static  void test(){
            System.out.println("我爱你");
        }
        public  static  String test(String str){
       String str1 = str;
      return str1;
        }
}
}
#注:思考一下Java为什么不用返回值类型来区分方法重载

Pragma mark — NO.3 成员变量和局部变量

123.png

Pragma mark — NO.4 类的封装—四种修饰符的用法

111.png

类的简单封装

public class JavaExample {
    public static void main(String[] args){

       //操作person类
        Person p = new Person();
        //因为我们的Person里的成员变量是私有属性，所以我们不能用点语法弄
       // p.age = 10000;
       //您设置的年龄不合理
        p.setAge(1000);

     }

       public static class Person{
            //使用private修饰成员变量
           private  String name;
           private  int age;

           //提供方法来操作name成员变量
          public  void setName(String name){
              //执行合理检验, 要求用户名必须在2-6位之间
              if (name.length() > 6 || name.length() < 2){
                  System.out.println("您设置的名字不符合要求");
                  return;
              }else{
                  this.name = name;
              }
          }
          //get方法获得Name
           public String getName(){

              return this.name;
           }

           //提供方法操作age
           public  void setAge(int age){
               if (age > 100 || age < 0){
                   System.out.println("您设置的年龄不合理");
                   return;
               }else {
                   this.age = age;
               }
           }
           public  int getAge(){

               return this.age;
           }
      }
}

Pragma mark — NO.5 构造函数

public class JavaExample {
    public static void main(String[] args){

         Person p = new Person("我",18);

     }
       public static class Person{
             public  String name;
             public  int count;
             //为了保证使用者还能够用系统默认的构造方法，我们重写一下
             public Person(){

             }
             //提供自定义的构造器，该构造器包含两个方法
           public  Person(String name, int count){
                 this.name = name;
                  this.count = count;
             }
       }
}

讲解:

Snip20170601_3.png

Pragma mark — NO.6 什么是多态

Snip20170601_4.png

Pragma mark — NO.7 简单单例的写法

public class FiveInARow {
    public static void main(String[] args) throws Exception {

            //创建Singleton对象不能通过构造器了
        //只能通过getInstance这个实例方法来创建了
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();

        System.out.println(s1);
        System.out.println(s2);
    }
    //单例
    static class  Singleton{
        //使用一个类变量来缓存曾经创建的实例
        private  static Singleton instance;
        //对构造器使用private修饰，隐藏该构造器
        private  Singleton(){}
        //提供一个静态方法，用于返回Singleton实例
        //该方法可以加入自定义控制,保证只产生一个Singleton实例
        //static修饰的就是类方法了
        public  static  Singleton getInstance(){

            if (instance == null){
                instance = new Singleton();
            }
            return instance;
        }
    }
}

Pragma mark — NO.8 final 关键字

Snip20170601_5.png