java学习（五）java类继承

1.制作一个工具类的文档

javadoc -d 目录 -author -version   arrayTool.java

实例：

class arrayDemo
{
   public static void main(String[] args){
 
       int[] arr = {23,34,54,65,57,7};
 
       //遍历数组
       arrayTool.printArray(arr);
       //获取数组中的最大值
       int max = arrayTool.getMax(arr);
       System.out.println("数组中的最大值为"+max);
       //获取数组中元素的索引
       int index = arrayTool.getIndex(arr,57);
       System.out.println("57在数组中的索引位置为"+index);
 
   }
 
}

生成工具类的文档类型
javac -d doc -author -version arrayTool.java
/**
 *数组操作工具类
 *@author greymouster
 *@version v1.0
 */
public class arrayTool
{
    /**
     *私有的构造方法 禁止外部实例化对象
     */
    private arrayTool(){}
 
    /**
     *遍历数组方法  遍历后为[元素1,元素2,元素3,....]
     *@param  arr 要遍历的数组
     */
    public static void printArray(int[] arr){
         System.out.print("[");
         for(int x=0;x<arr.length;x++){
            if(x == arr.length-1){
               System.out.println(arr[x]+"]");
            }else{
               System.out.print(arr[x]+",");
            }
         }
    }
 
    /**
     *获取数组中最大值的方法
     *@param arr 数组
     *@return 返回数组中的最大值
     */
    public static int getMax(int[] arr){
         //加入数组的元素为最大值
         int max = arr[0];
 
         for(int x=1;x<arr.length;x++){
             if(max<arr[x]){
                 max = arr[x];
             }
         }
 
        return max;
    }
 
    /**
     *获取数组中值的索引
     *@param arr 数组  value 数组中的值
     *@return index  返回数组中值所在的索引 如果不存在返回-1.
     */
    public static int getIndex(int[] arr,int value){
 
       int index = -1;
 
       for(int x=0;x<arr.length;x++){
           if(arr[x] == value){
               index = x;
           }
       }
 
       return index;
    }
 
}

2.java中不支持多继承，支持多层继承

class A extends B,C{}  //错误
 
//以下是多层继承关系
class A {
 
       public static void method(){
            System.out.println("ceshi");
      }
}
 
class B extends A{
 
       public static void  show(){
            System.out.print("ceshi1");
       }
}
 
class C extends B{
      public static void main(Stirng[] args){
               B  b = new B();
               b.show();
               b.method();
      }
}

子类不能继承父类的构造方法，但是可以通过supper关键字去访问父类构造方法

子类中所有的构造方法默认都会访问父类中无参数的构造方法

因为子类会继承父类中的数据，可能还会使用父类的数据

所以，子类初始化之前，一定要先完成父类数据的初始化

注意：每个构造方法的第一条语句默认都是：super()

super 和this的区别：

/*
    问题是：
        我不仅仅要输出局部范围的num，还要输出本类成员范围的num。怎么办呢?
        我还想要输出父类成员范围的num。怎么办呢?
            如果有一个东西和this相似，但是可以直接访问父类的数据就好了。
            恭喜你，这个关键字是存在的：super。
 
    this和super的区别?
        分别是什么呢?
            this代表本类对应的引用。
            super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)
 
        怎么用呢?
            A:调用成员变量
                this.成员变量 调用本类的成员变量
                super.成员变量 调用父类的成员变量
            B:调用构造方法
                this(...)    调用本类的构造方法
                super(...)    调用父类的构造方法
            C:调用成员方法
                this.成员方法 调用本类的成员方法
                super.成员方法 调用父类的成员方法
*/
class Father {
    public int num = 10;
}
 
class Son extends Father {
    public int num = 20;
 
    public void show() {
        int num = 30;
        System.out.println(num);  // 30
        System.out.println(this.num);   //20
        System.out.println(super.num);  //10
    }
}
 
class ExtendsDemo5 {
    public static void main(String[] args) {
        Son s = new Son();
        s.show();
    }
}

通过super（）方法去访问父类中的带参构造方法

class  Father{
 
     public  Father(String name){
            System.out.println("带参构造方法");
     }
}
 
class Son extends Father{
     public  Son(){
         super("随便给");
         System.out.println("无参构造方法");
     }
 
     public  Son(String name){
          //super("随便给");
                this();
          System.out.println("有参构造方法");
     }
}
 
class ExtendsDemo{
 
      public static void main(String[] args){
            Son s = new Son();
 
            System.out.println("--------------");
            Son s2 = new Son("daican");
    }
}

方法重写和方法重载

方法重写：子类中出现了和父类中方法声明一模一样的方法

方法重载：本类中出现了方法名一样，参数列表不同的方法，与返回值无关

/*
    猫狗案例讲解
 
    先找到具体的事物，然后发现具体的事物有共性，才提取出一个父类。
 
    猫：
        成员变量：姓名，年龄，颜色
        构造方法：无参，带参
        成员方法：
            getXxx()/setXxx()
            eat()
            palyGame()
    狗：
        成员变量：姓名，年龄，颜色
        构造方法：无参，带参
        成员方法：
            getXxx()/setXxx()
            eat()
            lookDoor()
 
    共性：
        成员变量：姓名，年龄，颜色
        构造方法：无参，带参
        成员方法：
            getXxx()/setXxx()
            eat()
 
    把共性定义到一个类中，这个类的名字叫：动物。
    动物类：
        成员变量：姓名，年龄，颜色
        构造方法：无参，带参
        成员方法：
            getXxx()/setXxx()
            eat()
 
        猫：
            构造方法：无参，带参
            成员方法：palyGame()
        狗：
            构造方法：无参，带参
            成员方法：lookDoor()
*/
//定义动物类
class Animal {
    //姓名
    private String name;
    //年龄
    private int age;
    //颜色
    private String color;
 
    public Animal() {}
 
    public Animal(String name,int age,String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }
 
    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;
    }
 
    public String getColor() {
        return color;
    }
 
    public void setColor(String color) {
        this.color = color;
    }
 
    public void eat() {
        System.out.println("不要睡了,该吃饭了");
    }
}
 
//定义猫类
class Cat extends Animal {
    public Cat() {}
 
    public Cat(String name,int age,String color) {
        super(name,age,color);
    }
 
    public void playGame() {
        System.out.println("猫玩英雄联盟");
    }
}
 
//定义狗类
class Dog extends Animal {
    public Dog() {}
 
    public Dog(String name,int age,String color) {
        super(name,age,color);
    }
 
    public void lookDoor() {
        System.out.println("狗看家");
    }
}
 
//测试类
class ExtendsTest5 {
    public static void main(String[] args) {
        //测试猫
        //方式1
        Cat c1 = new Cat();
        c1.setName("Tom");
        c1.setAge(3);
        c1.setColor("白色");
        System.out.println("猫的名字是："+c1.getName()+";年龄是："+c1.getAge()+";颜色是："+c1.getColor());
        c1.eat();
        c1.playGame();
        System.out.println("---------------");
 
        //方式2
        Cat c2 = new Cat("杰瑞",5,"土豪金");
        System.out.println("猫的名字是："+c2.getName()+";年龄是："+c2.getAge()+";颜色是："+c2.getColor());
        c2.eat();
        c2.playGame();
 
    }
}