Java方法详解：从入门到实战，掌握代码复用的核心

1
- 1.类变量：属于类，在内存中只有一份，用类名调用
2
- 2.实例变量：属于对象，每一个对象都有一份，用对象调用

1
public class User{
2
    public static int number;
3
    //每次创建对象时，number自增一下
4
    public User(){
5
        User.number++;
6
    }
7
}

1
public class Test{
2
    public static void main(String[] args){
3
        //创建4个对象
4
        new User();
5
        new User();
6
        new User();
7
        new User();
8

9
        //查看系统创建了多少个User对象
10
        System.out.println("系统创建的User对象个数："+User.number);
11
    }
12
}

1
public class Test2{
2
    public static void main(String[] args){
3
        //1.调用Student类中的类方法
4
        Student.printHelloWorld();
5

6
        //2.调用Student类中的实例方法
7
        Student s = new Student();
8
        s.printPass();
9

10
        //使用对象也能调用类方法【不推荐，IDEA连提示都不给你，你就别这么用了】
11
        s.printHelloWorld();
12
    }
13
}

1
1.类方法：static修饰的方法，可以被类名调用，是因为它是随着类的加载而加载的；
2
         所以类名直接就可以找到static修饰的方法
3

4
2.实例方法：非static修饰的方法，需要创建对象后才能调用，是因为实例方法中可能会访问实            例变量，而实例变量需要创建对象后才存在。
5
          所以实例方法，必须创建对象后才能调用。

1
//比如这是一个登录界面
2
public class LoginDemo{
3
    public static void main(String[] args){
4
        System.out.println(MyUtils.createCode());
5
    }
6
}

1
//比如这是一个注册界面
2
public class registerDemo{
3
    public static void main(String[] args){
4
        System.out.println(MyUtils.createCode());
5
    }
6
}

1
public class MyUtils{
2
    //私有化构造方法：这样别人就不能使用构造方法new对象了
3
    private MyUtils(){
4

5
    }
6

7
    //类方法
8
    public static String createCode(int n){
9
       ...
10
    }
11
}

1
public class Student {
2
    static int number = 80;
3
    static String schoolName = "黑马";
4
    // 静态代码块
5
    static {
6
        System.out.println("静态代码块执行了~~");
7
        schoolName = "黑马";
8
    }
9
}

1
public class Test {
2
    public static void main(String[] args) {
3
        // 目标：认识两种代码块，了解他们的特点和基本作用。
4
        System.out.println(Student.number);
5
        System.out.println(Student.number);
6
        System.out.println(Student.number);
7

8
        System.out.println(Student.schoolName); // 黑马
9
    }
10
}

1
public class Test {
2
    public static void main(String[] args) {
3
        Student s1 = new Student();
4
        Student s2 = new Student("张三");
5
        System.out.println(s1.age);
6
        System.out.println(s2.age);
7
    }
8
}

1
public class A{
2
    //公开的成员
3
    public int i;
4
    public void print1(){
5
        System.out.println("===print1===");
6
    }
7

8
    //私有的成员
9
    private int j;
10
    private void print2(){
11
        System.out.println("===print2===");
12
    }
13
}

1
public class B extends A{
2
    public void print3(){
3
        //由于i和print1是属于父类A的公有成员，在子类中可以直接被使用
4
        System.out.println(i); //正确
5
        print1(); //正确
6

7
        //由于j和print2是属于父类A的私有成员，在子类中不可以被使用
8
        System.out.println(j); //错误
9
        print2();
10
    }
11
}

1
public class Test{
2
    public static void main(String[] args){
3
        B b = new B();
4
        //父类公有成员，子类对象是可以调用的
5
        System.out.println(i); //正确
6
        b.print1();
7

8
        //父类私有成员，子类对象时不可以调用的
9
        System.out.println(j); //错误
10
        b.print2(); //错误
11
    }
12
}

1
public class People{
2
    private String name;
3

4
    public String getName(){
5
        return name;
6
    }
7
    public void setName(String name){
8
        this.name=name;
9
    }
10
}

1
public class Test {
2
    public static void main(String[] args) {
3
        // 目标：搞清楚继承的好处。
4
        Teacher t = new Teacher();
5
        t.setName("播仔");
6
        t.setSkill("Java、Spring");
7
        System.out.println(t.getName());
8
        System.out.println(t.getSkill());
9
        t.printInfo();
10
    }
11
}

1
public class Demo {
2
    public static void main(String[] args) {
3
        Fu f = new Fu();
4
        // f.privateMethod();    //私有方法无法使用
5
        f.method();
6
        f.protectedMethod();
7
        f.publicMethod();
8
    }
9
}

1
public class Zi extends Fu {
2
    //在不同包下的子类中，只能访问到public、protected修饰的方法
3
    public void test(){
4
        // privateMethod(); // 报错
5
        // method(); // 报错
6
        protectedMethod();    //正确
7
        publicMethod();    //正确
8
    }
9
}

1
public class Demo2 {
2
    public static void main(String[] args) {
3
        Fu f = new Fu();
4
        // f.privateMethod(); // 报错
5
        // f.method();          //报错
6
        // f.protecedMethod();//报错
7
        f.publicMethod();    //正确
8

9
        Zi zi = new Zi();
10
        // zi.protectedMethod();
11
    }
12
}

1
public class A {
2
    public void print1(){
3
        System.out.println("111");
4
    }
5

6
    public void print2(int a, int b){
7
        System.out.println("111111");
8
    }
9
}

1
public class B extends A{
2
    // 方法重写
3
    @Override // 安全，可读性好
4
    public void print1(){
5
        System.out.println("666");
6
    }
7

8

9
    // 方法重写
10
    @Override
11
    public void print2(int a, int b){
12
        System.out.println("666666");
13
    }
14
}

1
public class Test {
2
    public static void main(String[] args) {
3
        // 目标：认识方法重写，掌握方法重写的常见应用场景。
4
        B b =  new B();
5
        b.print1();
6
        b.print2(2, 3);
7
    }
8
}

1
- 1.重写的方法上面，可以加一个注解@Override,用于标注这个方法是复写的父类方法
2
- 2.子类复写父类方法时，访问权限必须大于或者等于父类方法的权限
3
    public > protected > 缺省
4
- 3. 重写的方法返回值类型，必须与被重写的方法返回值类型一样，或者范围更小
5
- 4. 私有方法、静态方法不能被重写，如果重写会报错。

1
public class Test {
2
    public static void main(String[] args) {
3
        Student s = new Student("播妞", 19);
4
        // System.out.println(s.toString());
5
        System.out.println(s);
6
    }
7
}

1
public class F {
2
    String name = "父类名字";
3

4
    public void print1(){
5
        System.out.println("==父类的print1方法执行==");
6
    }
7
}

1
public class Test {
2
    public static void main(String[] args) {
3
        // 目标：掌握子类中访问其他成员的特点：就近原则。
4
        Z z = new Z();
5
        z.showName();
6
        z.showMethod();
7
    }
8
}

1
this(): 调用本类的空参数构造器
2
this(参数): 调用本类有参数的构造器

1
访问本类成员：
2
    this.成员变量    //访问本类成员变量
3
    this.成员方法    //调用本类成员方法
4
    this()           //调用本类空参数构造器
5
    this(参数)      //调用本类有参数构造器
6

7
访问父类成员：
8
    super.成员变量    //访问父类成员变量
9
    super.成员方法    //调用父类成员方法
10
    super()           //调用父类空参数构造器
11
    super(参数)      //调用父类有参数构造器
12

13
注意：this和super访问构造方法，只能用到构造方法的第一句，否则会报错。