Java学习3.0 面向对象 （高级篇）

6.1    继承的基本概念
    1.类的继承格式：
        class 父类{}
        class 子类 extends 父类{}
    2.子类对象在实例化之前会默认调用父类中的构造方法
        子类构造器中隐含super（）的语法意思是调用父类的无参构造器
6.2    方法的覆盖（子类中定义了父类中同名的方法）
    3.子类覆盖父类时子类的方法权限要大于父类
       父类使用public子类也必须使用public
        private<default<public
6.3 super关键字的作用
    4.super必须在子类构造器的首行
    5.在子类中可以直接通过super.调用父类中的方法

继承的应用实例：

package com;

}
class Array{
    private int temp[];//数组的定义
    private int foot;//定义数组的脚标
    public Array(int len){
        if (len>0){
            this.temp=new int[len];//设置数组长度
        }else {
            this.temp=new int[1];//设置默认长度
        }
    }
    public boolean add(int i){
        if (this.foot<this.temp.length){//判断数组是否已经满了
            this.temp[foot]=i;//没满继续加
            foot++;//修改脚标
            return true;

        }else {
            return false;//添加失败
        }
    }
    public int[] getArray(){//获取全部数组
        return this.temp;
    }
}
class ReverseArray extends Array{//定义数组反转类
    public ReverseArray(int len){//设置数组大小
        super(len);//调用父类构造器
    }
    public int[] getArray(){//覆写getArray
        int center = super.getArray().length/2;//中间索引
        int head =0;//头部索引
        int tail=super.getArray().length-1;//尾部索引
        for (int x=0;x<center;x++){
            int temp=super.getArray()[head];//获取元素
            super.getArray()[head]=super.getArray()[tail];
            super.getArray()[tail]=temp;
            head++;
            tail--;

        }
return super.getArray();



    }

}
class SortArray extends Array{//数组排序子类
  public SortArray(int len){//接收数组个数
      super(len);
  }
  public int[] getArray(){
      java.util.Arrays.sort(super.getArray());//数组排序处理
      return super.getArray();//返回排序后的数组
  }
}

测试反转类：

public class ArrayDemo {
    public static void main(String[] args) {
        ReverseArray a=null;
        a=new ReverseArray(5);
        System.out.println(a.add(23)+"\t");
        System.out.println(a.add(21)+"\t");
        System.out.println(a.add(2)+"\t");
        System.out.println(a.add(42)+"\t");
        System.out.println(a.add(5)+"\t");
        System.out.println(a.add(6)+"\t");
        print(a.getArray());

    }
    public static void print(int i[]){
        for (int x=0;x<i.length;x++){
            System.out.print(i[x]+",");
        }
    }

结果：

true	
true	
true	
true	
true	
false	
5,42,2,21,23,

测试排序类：

public class ArrayDemo {
    public static void main(String[] args) {
        SortArray a=null;
        a=new SortArray(5);
        System.out.println(a.add(23)+"\t");
        System.out.println(a.add(21)+"\t");
        System.out.println(a.add(2)+"\t");
        System.out.println(a.add(42)+"\t");
        System.out.println(a.add(5)+"\t");
        System.out.println(a.add(6)+"\t");
        print(a.getArray());

    }
    public static void print(int i[]){
        for (int x=0;x<i.length;x++){
            System.out.print(i[x]+",");
        }
    }

结果：

true	
true	
true	
true	
true	
false	
2,5,21,23,42,

6.4 final 关键字
    6.final在Java中表示的意思是最终的意思，也可以称为完结器。可以使用final 关键字声明类，属性，方法
    7.在声明时要注意：
        final声明的类不能有子类；
        eg：
            final classA {}
            class B extends A{}   不能被继承，继承到头了

        final声明的类不能被覆盖；
        eg：
            class A{
               public final void print（）{
                system.out.print{“Hello”}
                   }
                }
            class B extends A{
              public final void print（）{
                system.out.print{“Hello”}
                   }
            }        不能被子类覆盖
        final声明的变量为常量，常量不可以被修改；
        eg：
            private final String INFＯ＝“Ｈｅｌｌｏ”
            public final void print(){     INFO="hai"    } 不能被修改
    8.final 声明变量时要求全字母大写
    9.如果一个程序中使用 public static final 则称为全局常量
6.5 抽象类的基本概念
    Java可以创建一种专门的类用来当作父类，类似与模板。但不能直接使用抽象类创建对象，只能通过抽象类派生出新的类，再来创建对象。
    10.抽象类的定义及其使用规则：
        包含一个程抽象方法的类称必须是抽象类；
        抽象类和抽象方法都要使用abstract关键字声明；
        抽象方法只需要声明不需要实现；
        抽象类必须被子类继承，子类（如果不是抽象类）必须覆盖抽象类中的全部抽象方法；
    11.抽象类格式定义：
        absteact class 抽象类名称{
        属性；
        访问权限 返回值类型 方法名称（参数）{
         [rerurn 返回值]
            }
        访问权限 absteact 返回值类型 方法名称（参数）；
        \\在抽象方法中没有方法体
        }
    12.抽象类与普通类的区别：
        普通类可以根据自己的需求选择性的对父类方法进行覆写
        抽象类则强制要求子类覆写父类方法
    13.注意：
        抽象类不能使用final关键字修饰    无法被继承但抽象类必须被子类继承
        不要使用private声明        方便子类进行覆写
        抽象类中允许存在构造方法
6.6 接口的基本概念
    接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法组成。
    14.接口的定义格式：（接口的权限默认是public，默认变量是全局变量，默认方法是抽象方法）
        interface 接口名称{
             全局变量；
             抽象方法；
            }
    15.实现接口：
        class 子类 implements 接口A，接口B，......{    }
        一个子类可以继承多个接口，但要覆写全部的接口
    17.如果在开发中既要实现继承接口又要实现继承抽象类可以：
        class 子类 extends 抽象类 implements 接口A，接口B......{    }
    18,允许抽象类继承接口
        abstract class B implements A{}
    19.接口可以继承多个接口
        interface 子类接口 extends 父类接口A， 父类接口B......{    }