2019-9-11【Javase】可变参数、命令行传参、递归、封装、重载、构造

可变参数

区别：

1.数组参数，可以有一个，可以有多个；
可变参数只能有一个；
2.数组参数，位置任意；
可变参数只能放在最后；
3.数组参数，传参 只能传入一个数组类型[];
可变参数传参，可不给参数，可给多个参数，可传一个数组。

public class TestVarParam {
    // 数组作为参数：
    public void f(int [] arr,int [] arr1,int [] arr3) {
        System.out.println(Arrays.toString(arr));
    }
    // 可变参数:底层是数组
    public void ff(int ... arr) {
        System.out.println(Arrays.toString(arr));
        System.out.println(arr.length);
    }
    public static void main(String[] args) {
        TestVarParam test = new TestVarParam();
        int [] arr = new int[] {11,22,33};
//      test.f(arr);
​
        // 匿名对象:只使用一次
//      test.f(new int[] {11,22,33},arr,arr);
//      test.ff(arr);// 数组
//      test.ff();// new int[]{}
//      test.ff(11);// new int[]{11}
        test.ff(11,22,33);// new int[]{11,22,33};
​
    }
​
}

命令行传参（了解）

F:\workspace17\project17\bin>java day0806.TestMain
[]
0
​
F:\workspace17\project17\bin>java day0806.TestMain aa
[aa]
1
​
F:\workspace17\project17\bin>java day0806.TestMain aa bb cc
[aa, bb, cc]
3
​
F:\workspace17\project17\bin>java day0806.TestMain aa bb cc "h e l l o"
[aa, bb, cc, h e l l o]
4
​

递归

允许程序调用自身的一种方式。

特点:

1.反复调用自身；
2.是个方法
3.出口（结束反复调用执行过程的条件）。

 public int func(int n) {
        if(n == 1)
            return 1;
        else 
            return n * func(n-1); // 累乘
    }

封装

封装： 隐藏了实现细节，对外只提供公共的访问方式。
语法：

class Person{
     // 私有
     private int age;// 22  
     // setter访问器
     public void setAge(int age) {// int age1 = 122;
         if(age >= 18 && age <= 65) {
             this.age = age;// age = 22;
         }else {
             System.out.println("赋值必须是18-65之间");
             this.age = 0;// 默认值
         }
     }
     //getter访问器
     public int getAge() {
         return age;
     }
    
}
public class TestPerson {
​
    public static void main(String[] args) {
        Person zhangsan = new Person();

    zhangsan.setAge(122);
    System.out.println(zhangsan.getAge());


    }
​
}

好处:
1.提供了安全性；
2.用户只能用我提供的公共的访问方式来访问；
3.访问器中可以使用流程控制语句。

重载

方法重载：

通常 同一个类中，
方法名相同，
参数列表必须不同（个数，类型，顺序），
与返回值无关。

public class TestOverload {
​
    public void f() {
        System.out.println("无参");
    }
    public void f(int n) {
        System.out.println("int");
    }
    public void f(byte n) {
        System.out.println("byte");
    }
    public void f(short n) {
        System.out.println("short");
    }
    public void f(long n) {
        System.out.println("long");
    }
    public void f(char n) {
        System.out.println("char");
    }
    public void f(float n) {
        System.out.println("flaot");
    }
    public void f(double n) {
        System.out.println("double");
    }
    public void f(int n1 ,double n2) {
        System.out.println("int_double");
    }
    public void f(double n1, int n2) {
        System.out.println("double_int");
    }
    public void f(int ...arr) {// 5.0 
        System.out.println("int...arr");
    }
    //不能重载
/*  public void f(int []ar) {
 

   
}*/
public void f(String ...arr) {
    
}
public static void main(String[] args) {
    TestOverload test = new TestOverload();
    test.f(11);//
//      test.f(11, 22.2); 
//      test.f(11.1,22);
//      test.f(11);// int
//      test.f((byte)11);// byte
//      test.f(11.1); // double
//      test.f(11.1f); // float
    
​
    }
​
}

构造

public 类名(){ // 初始化对象}
private

1） 没有显示定义构造器，那么编译器才会分配一个默认构造。
2）代码中显示定义了构造，那么默认构造就不存在了。
3） 带参构造，要按顺序传参。
作用：初始化对象

默认构造：

/**
 * 学员类
 * @author Guojing
 */
class Student{
    private int no;// 0
    private String name;// null
    private int age;// 0
    /*
     * 分配默认构造：
     * Student(){// 调用父类构造}
     */
​
    //访问器
    public void setNo(int no) {
        this.no = no;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String show() {
        return no + "," + name + "," + age;
    }
}
​
public class TestStudent {
​
    public static void main(String[] args) {
        //                       调用构造方法
        Student guojing = new Student();
​
        System.out.println(yangkang.show());
    
    }
​
}

无参构造：

 /**
     * 学员类
     * @author Guojing
     */
class Student{
    private int no;// 0
    private String name;// null
    private int age;// 0
​
    // 无参
    public Student() {
        
    //初始化
    no = 11;
    name = "郭靖";
    age = 22;


    }
​
    //访问器
    public void setNo(int no) {
        this.no = no;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String show() {
        return no + "," + name + "," + age;
    }
}
​
public class TestStudent {
​
    public static void main(String[] args) {
        //                       调用构造方法
        Student guojing = new Student();
​
        System.out.println(guojing.show());
​
    
    }
​
}

带参构造：

/**
 * 学员类
 * @author Guojing
 */
class Student{
    private int no;// 0
    private String name;// null
    private int age;// 0
​
    public Student(int no,String name,int age) {
        this.no = no;
        this.name = name ;
        this.age = age;
    }
    //访问器
    public void setNo(int no) {
        this.no = no;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String show() {
        return no + "," + name + "," + age;
    }
}
​
public class TestStudent {
​
    public static void main(String[] args) {
        //                       调用构造方法
        Student guojing = new Student(11,"郭靖",22);
        System.out.println(guojing.show());
        Student yangkang = new Student(22,"杨康",33);
        System.out.println(yangkang.show());
    
    }
​
}

构造和普通方法区别：

1.构造只用来初始化对象；
普通 是为了完成 某个特定的功能；
2.只有在创建对象的时候 才能调用构造；
在需要使用的时候，用对象调用就可以了。

构造器和访问器区别：

1.构造可以一次性给所有 成员变量赋值；
访问器只能逐个 调用赋值；
2.构造 对象创建完成后 ，所有的成员变量都赋值成功；
访问器 对象创建完后，采取的都是系统的默认值，需要逐个调用setter访问器 赋值；
3.构造方法 只能完成赋值，不能修改值，修改需要setter访问器；
4.构造方法 只能赋值，不能访问值，访问值 需要getter访问器。

构造器调用：

this()语句；

1. 必须用this()调用本类构造；
2. this()必须写在构造器中；
   3.this() 必须写在构造的第一行代码处。

调用带参构造：

class Role{
    private String name;
    private int age;
    private String sex;
    private String address;
    private String job;
​
    public Role() {
        this.name = "匿名";
    
}
public Role(String job) {// Sting job = "杀手"
    this();// 调用无参构造
    this.job = job;//this.job = "杀手“
    
}
public Role(String name,String sex,String job) {
    this(name,sex,0,job,null);// 调用带参数的构造
}
public Role(String name,String sex,int age ,String job,String address) {
    this.name = name;
    this.sex = sex;
    this.age = age;
    this.job = job;
    this.address = address;
}
public String show() {
    return name + "," + sex + "," + age + "," + job + "," + address;
}
}
public class TestRole {
    public static void main(String[] args) {
        Role yangtiexin = new Role("杨铁心","男","英雄");
        System.out.println(yangtiexin.show());
    
    Role person = new Role();
    System.out.println(person.show());
    Role killer = new Role("杀手");
    System.out.println(killer.show());
    Role ouyangke = new Role("欧阳克", "男", "白驼山少主");
    System.out.println(ouyangke.show());
    Role guojing = new Role("郭靖", "男", 18, "大侠", "内蒙古");
    System.out.println(guojing.show());

    }
​
}