继承关系&修饰符

继承

继承描述的类与类之间的关系,一般把多个子类的共性抽取到一个父类中,子类和父类就是继承关系。

举例 学生和老师以及人类的关系

• 人类

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

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

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

    //行为:吃饭
    public void eat(String food){
        System.out.println("正在吃"+food);
    }

}

• 学生类

public class Student extends Person{
    //学号
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
    //行为:学习
    public void study(String subject){
        System.out.println("学生努力学习"+subject);
    }
}

• 老师类

public class Teacher extends Person {
    public void teach(String subject){
        System.out.println("老师努力讲"+subject);
    }
}

• 测试类

public class Demo1 {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setId("12345");
        stu.setName("张三");
        stu.setAge("20");

        String id = stu.getId();
        String age = stu.getAge();
        String name = stu.getName();
        System.out.println(id);
        System.out.println(name);
        System.out.println(age);
        System.out.println("----------");

        stu.eat("8元管饱");
        stu.study("Java");

        System.out.println("------------");
        Teacher t=new Teacher();
        t.setName("老王");
        t.setAge("18");
        //t.setId("006");Teacher类和Person都没有，会报错
    }
}

继承中成员的访问

• 成员变量的访问

遵循就近原则:
子类局部有就用局部,局部没有就找子类成员的,子类成员没有就使用父类成员的。最终找不到就报错
当父类和子类有同名的成员变量时,就可以使用this和super进行区分
this.成员变量: 本类的成员变量
super.成员变量: 父类的成员变量

//动物类(父类)
public class Animal {
   public int age=10;
}

//狗类(子类)
public class Dog extends Animal {
    int age=2;
    public void show(){
        int age=6;
        System.out.println(age); //6
        System.out.println(this.age); //2   this.age 表示本类的成员变量age
        System.out.println(super.age); //10  super.age 表示父类的成员变量的age
    }
}
//测试类
public class Demo2 {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.show();
    }
}

成员方法的访问

• 如果子类有就用子类的，子类没有就用父类；

• 子类和父类有"一模一样"的方法，就用子类自己的方法。这种现象叫做【方法重写\复写\覆盖】

• 方法重写的注意事项

  • @Override 是一个注解（用来标识一个方法是否符合重写的规则）
  • 方法名一样
  • 参数列表一样(参数类型和个数)
  • 返回值类型子类要小于等于父类（了解，一点用没有）
  • 子类权限要大于等于父类
    public > protected > 默认的(不写) > private
    

• 方法重写的意义
  当父类方法不满足子类要求时,在保证父类方法不变的前提下,子类可以做自己的实现

public class Animal {
  public void eat(){
      System.out.println("动物吃东西");
  }
}

public class Dog extends Animal {
    //复写父类方法
    @Override
    public void eat(){
        System.out.println("狗吃骨头");
    }
    //看家(子类特有方法)
    public void lookHome(){
        System.out.println("狗在看家");
    }

}

public class Demo4 {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();//复写的方法
        d.lookHome();
    }
}

• 构造方法的访问
  格式:

 public 类名(参数列表){
 ...
 }

构造方法什么时候执行?

创建对象的时候执行（每次new 一个对象，都会执行构造方法）

继承中构造方法如何访问

1.在每一个构造方法的第一行，都会隐含的有一句super()，去调用父类的空参数构造方法
2.如果不想去调用父类的空参数构造方法，可以手动的使用super(参数)，去调用父类的有参数构造方法
3.this(...)和super(...) 只能出现的构造方法的第一句

其他修饰符

• 权限修饰符
  权限修饰符一共有四种,用来控制类的成员的作用范围

public > protected > 默认的(不写) > private

protected: 被protected修饰的变量或者方法，只给本类和子类使用；同一个包中也能访问
默认的： 被默认的修饰的变量或者方法，只能在同一个包中使用

• final
  final是最终的意思,可修饰类、方法、变量

final修饰类
   不能被继承
final修饰方法
   不能被复写(重写)
final修饰变量
   -修饰局部变量: 变量值只能被赋值一次
   -修饰成员变量：没有默认值，必须手动赋值，但是变量值也只能被赋值一次
   注意事项：
      如果final修饰引用类型的变量，表示的是地址值不能被改变

举例

public static void main(String[] args){
    final Student s = new Student(23);
   s = new Student(24);  // 错误
   s.setAge(24);  // 正确
}

• static

1.静态属于类，不属于任何一个对象
2.【静态的变量或者方法，建议使用类名调用】
3.被静态修饰的变量可以被该类的多个对象共享

静态注意事项:

1. 静态方法中不能有this关键字
2. 静态方法只能调用静态方法和静态变量
3. 非静态方法可以调用静态方法，也可以调用静态变量

静态在实际开发中经常用来写工具类

/*
如果一个类中的所有方法，都是静态的，那么这个类就是工具类
好处：类名直接调用方法，特别方便
*/
/*
数组工具类：专门用于操作数组的
 */
public class ArrayUtils {
    //求数组元素的和
    public static int getSum(int[] array){
        int sum=0;
        for (int i = 0; i < array.length; i++) {
            sum+=array[i];
        }
        return sum;
    }

    //打印数组中的元素
    public static  void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
}

class Student {
public String name; //姓名
    public int age; //年龄
    public static String university; //学校 共享数据！所以设计为静态！
     public void show() {
        System.out.println(name + "," + age + "," + university);
    }
    }
public class StaticDemo {
    public static void main(String[] args) {
     // 为对象的共享数据赋值
        Student.university = "北京大学";
        
        Student s1 = new Student();
        s1.name = "林青霞";
        s1.age = 30;
        s1.show();
        
        Student s2 = new Student();
        s2.name = "风清扬";
        s2.age = 33;
        s2.show();
    }
    }