Java

1.static关键字概述

  • static修饰的成员具有特点:该成员不再属于对象,而属于类,就是静态方法和静态成员方法,和代码块,但是可以被该类的所有对象共享。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    public class Test {
    public static void main(String[] args) {
    //调用静态属性,从这里可以看出来,类是先加载出来,然后new Student()的时候,对象才会被加载
    //总之:是先有的静态方法(类加载),才会有对象方法(new Student())
    System.out.println("调用静态属性:"+Student.scName);
    System.out.println("------------------------------------------");

    // 创建学生对象
    Student s1 = new Student("张三", 23, "清华大学");
    Student s2 = new Student("李四", 24, "清华大学");

    // 调用对象方法 显示学生信息
    s1.show();
    s2.show();
    System.out.println("------------------------------------------");

    //修改静态变量
    //静态成员变量:在内存中只有一份,所有类的对象共用一个
    Student.scName = "百度程序员";
    s1.show();
    s2.show();
    System.out.println("------------------------------------------");

    // 调用对象的成员方法,非静态成员变量:只能通过对象名访问。
    //非静态成员变量:每次创建对象都会为成员变量分配内存并初始化,每一个对象都有自己的一份成员变量,互不干预。
    s1.name = "老王";
    s1.show();
    s2.show();
    System.out.println("------------------------------------------");

    //静态成员变量:可以通过对象名方法,也可以通过类名访问(强烈推荐使用)
    s1.scName="北大青鸟";
    s1.show();
    s2.show();
    }
    }

    class Student {
    // 姓名
    public String name;
    // 年龄
    private int age;
    // 学校名称 静态成员变量:有static修饰的,没有static修改的都是对象变量 或者是对象方法
    public static String scName = "清华大学";

    public Student() {
    super();
    }
    public Student(String name, int age, String scName) {
    super();
    this.name = name;
    this.age = age;
    this.scName = scName;
    }



    // 显示学生信息
    public void show() {
    System.out.println("姓名:" + name + ",年龄:" + age + ",学校名称:" + this.scName);
    }

    //get set 方法
    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修饰方法的注意事项

  • 静态方法中不能使用this和super关键字,因为这两个关键字是属于对象的
  • 因为先有的静态,后有的对象,所有静态方法调用对象中的方法是不行的,因为有静态的时候,还没有对象
  • 有什么不懂,参考先有的静态,然后才有的对象
  • 在工具类中定义的方法一般都是静态方法。(因为不用创建对象,就不需要消耗资源)
    • Math,Arrays,Collections数组工具类

2.final关键字概述

  • final可以修饰
    • 基本类变量 –> 该变量就是常量了,其值不能再次赋值
    • 引用类型变量–>该引用变量就不能再指向其他对象(该变量引用的地址值不能改变)
    • 方法–>不能被子类重写了
    • –>该类不能被继承了
    • 成员变量–>可以被继承,但是不能修改值

final修饰引用类型的变量,指其所引用的对象不能改变,即该变量引用的地址值不能改变。对象成员变量的值是可以修改的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
public class Test extends Mother {

public static void main(String[] args) {

//该变量就是常量了,其值不能再次赋值
//final修饰属性 情况一:如果第一次赋值null,之后再也不能赋值了
final String str = null;
//str = "3213"; //再赋值的时候就会报错

//final修饰属性 情况二:如果只是声明,就还能再次赋值
final String str2 ;
str2 = "3123";

//final修饰属性 情况三:调用final 修饰的形参列表,参考情况二,
final String str3 = "312";
method(str3);

//该引用变量就不能再指向其他对象
Father father = new Father();
Father father1;
//father = father1

//等下,还有个坑
final StringBuffer s = new StringBuffer("Hello");
s.append(" World!");
System.out.println(s);//结果为Hello World!

Mother mother = new Mother();
//mother.str = "312321"; //被final修改的成员变量可以被继承,但是不能被修改
System.out.println(mother.str);
mother.str2 = "3123123";
//从mother 继承下来的成员变量
System.out.println(str);
System.out.println(str2);
}

public static void method(final String string){
System.out.println(string);
}

// final 修改方法 不能被子类重写了
// @Override
// public void sperk() {
// super.sperk();
// }
}

//该类不能被继承了
final class Father{

}

//class Son extends Father{
//
//}

class Mother{
final public String str = "测试";
public String str2 = "测试2";

final public void sperk(){
System.out.println("我是父类");
}
}

3.四种访问权限修饰符

  • public:任意包下的任意类都可以访问
  • protected:任意包下的子类都可以访问
  • 默认(包权限):同包下的任意类都可以访问
  • private:只能在本类中使用

小结

只要是成员变量使用private修饰
只要是成员方法使用public修饰

4.内部类的概述

比如:在A类中定义了B类,B类称为内部类,A称为外部类。
内部类可以访问外部类的所有成员,包括private修饰的。
内部类的字节码文件:外部类名.内部类名.class

6.2 内部类分类
成员内部类(了解):定义在成员位置,和成员变量是同级别的。
局部内部类(了解):定义在外部类的方法中,和局部变量是同级别的。