学习Java第2天-Java类

本次更新实际上距离上次第一天已经过去2周，中间没有更新，主要是因为涉及到的循环控制语句，函数等都比较简单，学起来没啥压力，感觉没有记录的必要。昨天看完了类的课程，涉及的东西比较多，在此对重要的点记录一下。

java类权限控制

public

public是公共的，被public所修饰的成员可以在任何类中都能被访问到。

public能用来修饰类，在一个java源文件中只能有一个类被声明为public，而且一旦有一个类为public，那这个java源文件的文件名就必须要和这个被public所修饰的类的类名相同，否则编译不能通过。说到这里，穿插多一点知识。一个类作为外部类的时候只能被public或者默认访问修饰符所修饰，但是一个类如果作为内部类的时候，则可以被四种访问修饰符所修饰，因为一个类作为内部类的时候，就作为外部类的一个成员属性了，因此可以有四种访问修饰符修饰，这是内部类和外部类的一个区别

public用来修饰类中成员(变量和方法)，被public所修饰的成员可以在任何类中都能被访问到。通过操作该类的对象能随意访问public成员。

public在类的继承上的体现，被public所修饰的成员能被所有的子类继承下来。

protected

protected是受保护的，受到该类所在的包所保护。

被protected所修饰的成员会被位于同一package中的所有类访问到。同时，被protected所修饰的成员也能被该类的所有子类继承下来。(注意：这里是指同一个package或者不同的package中的子类都能访问)

default(friendly)

friendly是友好的，即在成员的前面不写任何的访问修饰符的时候，默认就是友好的。所谓友好的，是对同一package的类友好。

同一package中的所有类都能访问。被friendly所修饰的成员只能被该类所在同一个package中的子类所继承下来。(也就是说只有在同一个package中的子类才能访问到父类中friendly修饰的成员)

private

private是私有的，即只能在当前类中被访问到，它的作用域最小。

作用域	当前类	同一包	其他包的子类	其他包的类
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

java类构造器

相当于python中的def __init__(self)函数，不过java和python不同，python构造函数传递默认值是形参设置，而java则利用同名函数机制，实现可不传递参数，实例化类，也可传递部分参数，实例化类。

idea中快速构造器快捷键：control + enter

必须与类名相同

无返回值

java类的高内聚、低耦合实现

get/set

idea快捷键：control + enter

原则：成员不应暴露给外部直接调用，而应该将属性保护起来，提供get/set方法来操作成员属性。

Demo

Person.java

package top.junyipan.www.Entity;

public class Person {
    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Boolean getSex() {
        return sex;
    }

    public void setSex(Boolean sex) {
        this.sex = sex;
    }

    String name;
    Integer age;
    Boolean sex;

    public Person() {
        this.sex = false;
        this.age = 10;
    }

    public Person(String name, Integer age, Boolean sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    protected void eating() {
        System.out.println(this.name + "正在吃饭");
    }

    protected static void sleep(){
        System.out.println("人正在床上睡觉！");
    }
}

Student.java

package top.junyipan.www.Entity;


public class Student extends Person{
    protected void learn() {
        System.out.println(this.name + "正在学习！");
    }

    protected void exam() {
        System.out.println(this.name + "正在考试！");
    }
    protected int getRank() {
        return 10;
    }

    @Override
    protected void eating() {
        System.out.println(this.name + "吃火锅！");
    }

    protected static void sleep() {
        System.out.println("学生正在桌上睡觉！");
    }
}

Teacher.java

package top.junyipan.www.Entity;

public class Teacher extends Person{
    protected void speaking() {
        System.out.println(this.name + "正在讲课！");
    }
}

Main.java

package top.junyipan.www.Entity;

public class Main {
    public static void main(String[] args) {
        Teacher wang = new Teacher();
        wang.setName("老王");
        wang.setAge(35);
        wang.setSex(true);
        Student xm = new Student();
        xm.setName("小明");
        xm.setAge(12);
        xm.setSex(true);
        Student xh = new Student();
        xh.setName("小红");
        xh.setAge(14);

        System.out.println(wang.getAge());
        System.out.println(xh.getName());
        System.out.println(xh.getAge());
        System.out.println(xh.getSex());



        wang.speaking();
        xm.learn();
        xh.learn();
        wang.eating();
        xm.eating();
        xm.exam();
        System.out.println("小明考试成绩排名第" + xm.getRank());


        System.out.println("======================");
        Student s1 = new Student();
        s1.setName("s1");
        Person s2 = new Student();
        s2.setName("s2");
        s1.eating();
        s1.sleep();
        s2.eating();
        s2.sleep();

    }
}

35
小红
14
false
老王正在讲课！
小明正在学习！
小红正在学习！
老王正在吃饭
小明吃火锅！
小明正在考试！
小明考试成绩排名第10
======================
s1吃火锅！
正在桌上睡觉！
s2吃火锅！
正在床上睡觉！

封装-继承-多态

继承：extends
多态
- 父类和子类有相同的方法和参数
- 多态是方法的多态，属性没有多态
- 存在条件：继承关系，方法需要重写，父类引用指向子类对象
- 如果是static方法，最终调用的方法看左边；如果不是static方法，调用的是右边实例对象的方法
  - Student student = new Student(); student.eat() 调用的Student的eat方法
  - Person student = new Student(); student.eat()调用的Person的eat方法
- 不可继承的场景：
  - static方法，属于类，不属于实例
  - final 常量
  - private 方法(private方法不可继承，谈不上多态)

抽象类

关键字 abstract，一般写框架的时候会用，定义方法，但是不会实现它
抽象类不能被实例化，有构造方法
抽象类中的方法不一定全部是抽象方法，但是有抽象方法的类一定是抽象类

继承抽象类的子类也可以是抽象类，如果子类不是抽象类，则必须要实现父类的抽象方法

cooking.java

package top.junyipan.www.demo1;

/*抽象类*/
public abstract class Cooking {
    /*抽象方法*/
    public abstract void buyFood();
    public abstract void washFood();
    public abstract void cookFood();
    /*非抽象方法*/
    public void eatFood(){
        System.out.println("nice food!");
    }
}

cooker.java

package top.junyipan.www.demo1;

public class Cooker extends Cooking{
    @Override
    public void buyFood() {
        System.out.println("buying food...");
    }

    @Override
    public void washFood() {
        System.out.println("washing food...");
    }

    @Override
    public void cookFood() {
        System.out.println("cooking food...");
    }
}

Main.java

package top.junyipan.www.demo1;

public class Main {
    public static void main(String[] args) {
        Cooker wang = new Cooker();
        wang.buyFood();
        wang.washFood();
        wang.cookFood();
        wang.eatFood();
    }
}

接口

关键字interface，不再用class修饰
接口中的方法默认就是使用public abstract来修饰，表示公共抽象方法
接口中定义的方法，在实现接口的类中必须实现
接口中定义的属性是public static final修饰，但是一般接口中不定义属性
接口不能被实例化，接口中没有构造方法