封装 static静态关键字 可变参数 递归

一.封装

1.this

1.当成员变量和局部变量重名时,调用遵循"就近原则",先调用局部的

2.this代表的是当前对象,哪个对象调用this所在的方法,this就代表哪个对象

3.作用:区分重名的成员变量和局部变量(this后面肯定是成员的)

public class Person {
    String name;

    /**
     * 哪个对象调用的this所在的方法
     * this就代表哪个对象
     * @param name
     */
    public void speak(String name){
        System.out.println(this+"........this");
        System.out.println(this.name+"您好,我是"+name);
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person+".....person");
        person.name = "张三";
        person.speak("李四");

        System.out.println("===============");

        Person person1 = new Person();
        System.out.println(person1+".........person1");
        person1.name = "王五";
        person1.speak("赵六");
    }
}

2.构造方法

1.空参构造方法

• new对象使用
• 没有返回值,没有void,方法名和类名一致
• new就调用,构造方法会自动执行

public person(){

}

每一个类jvm都会给一个默认的空参构造,不写也有

2.有参构造方法

• new对象使用
• 为属性赋值
• jvm不会提供有参构造,需要自己写
• 如果写了有参构造,jvm不再提供空参构造,需要自己补上去

public person(参数){
	为属性赋值
}

    //空参构造
    public Person(){

    }

    //有参构造
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

3.标准javabean

1.具有私有成员变量

2.有空参和有参构造方法

3.有get set方法

4.类必须是具体的(非抽象 abstract)和公共的，public class 类名

public class Person {
    private String name;
    private int age;

    //无参构造
    public Person(){

    }

    //有参构造
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

二.static关键字

1.可以修饰一个成员变量,还可以修饰一个方法

2.特点

• 被static修饰的成员随着类的加载而加载
• 被static修饰的成员由于跟着类到内存,所以优先于对象存在
• 被static修饰的成员属于类成员,不属于对象成员(成员方法,成员变量)
• 根据static所在的类创建出来的对象,都会共享这个静态成员

3.使用

• 修饰成员变量: static 数据类型 变量名
• 修饰方法:
  修饰符 static 返回值类型 方法名(参数){
  方法体
  return 结果
  }

4.调用

• 类名直接调用

public class Student {
    String name;
    static String classRoom;

    //静态的方法
    public static void study(){
        System.out.println("学生要学习");
    }
}

public class Test01 {
    public static void main(String[] args) {
        //类名直接调用
        Student.classRoom = "222";


        Student s1 = new Student();
        s1.name = "张三";
        //s1.classRoom = "222";
        System.out.println(s1.name);
        System.out.println(s1.classRoom);

        //类名直接调用
        Student.study();

        System.out.println("====================");

        Student s2 = new Student();
        s2.name = "李四";
        //s2.classRoom = "222";
        System.out.println(s2.name);
        System.out.println(s2.classRoom);

        //类名直接调用
        Student.study();
    }
}

1.static修饰成员访问特点

• 非静态的能直接访问静态成员

  a.在同一个类中:直接调用,类名调用(实际上是直接调用),new对象调用(即使new对象调用的实际上也是直接调用的)

  b.不在同一个类中:类名调用,new对象调用(实际上也是类名直接调用)

• 静态的能直接访问非静态成员

  ​ 不能-> 静态成员随着类的加载而加载优先于非静态成员产生

  ​ 但是new对象可以访问非静态成员

• 非静态能直接访问非静态成员

  a.在同一个类中:直接调用,new对象调用

  b.不在同一个类中:new对象调用

• 静态的能直接访问静态成员

  a.在同一个类中:直接调用,类名调用,new对象调用

  b.不在同一个类中:类名调用,new对象调用

总结:

1.不管在不在同一个类中,只要是访问静态的:都可以使用类名点

2.不管在不在同一个类中,只要是访问非静态的:都可以new对象调用

补充:

• 静态成员随着类的加载而加载,如果所有成员都变成静态的,会过多的占用内存

• 1.共享数据 2.抽取工具类时 可以使用静态方法

public class ArraysUtils {
 //工具类不需要new对象调用,只需要类名调用,所以我们可以将构造方法变成私有的
 private ArraysUtils(){
 }

 public static void print(int[] arr){
     System.out.print("[");
     for (int i = 0; i < arr.length; i++) {
         if (i==arr.length-1){
             System.out.print(arr[i]+"]");
         }else{
             System.out.print(arr[i]+", ");
         }
     }
 }
}

public class Test02 {
 public static void main(String[] args) {
     int[] arr = {1,2,3,4,5};
     ArraysUtils.print(arr);
 }
}

public class Test03 {
 public static void main(String[] args) {
     int[] arr = {1,2,3,4,5,5,6,89,7,8,8,64};
     ArraysUtils.print(arr);
 }
}

三.可变参数

修饰符 返回值类型 方法名(非可变参数形参列表,参数类型. . . 形参名)

其实这个书写约等于

修饰符 返回值类型 方法名(非可变参数形参列表,参数类型[] 形参名)

• 一个方法最多有一个可变参数
• 如果一个方法包含可变参数，那么可变参数必须是形参列表的最后一个

例:n个字符串进行拼接，每一个字符串之间使用某字符进行分隔，如果没有传入字符串，那么返回空字符串""

public class Demo03{
    public static void main(String[] args) {
        String result = concat("-", "张无忌", "张翠山", "张三丰", "金毛狮王", "白眉鹰王", "青翼蝠王", "紫衫龙王");
        System.out.println("result = " + result);
    }

    public static String concat(String s, String... arr) {
        String str = "";
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                str += arr[i];
            } else {
                str += arr[i] + s;
            }
        }
        return str;
    }
}

四.递归

• 递归：指在当前方法内调用自己的这种现象。
• 递归的分类:
  • 递归分为两种，直接递归和间接递归。
  • 直接递归称为方法自身调用自己。
  • 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法。
• 注意事项：
  • 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出(因为会不断的压栈)。
  • 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。

示例一：需求:利用递归输出3到1

public class Demo01 {
    public static void main(String[] args) {
        method(3);
    }

    public static void method(int n) {
        if(n==1){
            System.out.println(n);
            return;
        }
        System.out.println(n);
        n--;
        method(n);
    }
}

示例二：求n!

public class Demo02 {
    public static void main(String[] args) {
        int result = method(4);
        System.out.println("result = " + result);
    }

    private static int method(int n) {
        if(n==1){
            return 1;
        }else{
            return n*method(n-1);
        }

    }
}