集训--6

1.Java继承的语法格式
Java继承的关键字是extends

格式：
public class 类名(子类、超类、派生类)   extends　类名(父类、基类) {

}
注意：
Java类的继承是单继承。

2.子类继承到了什么，能调用的有哪些？
子类继承到了父类所有的属性和方法。

类有访问修饰符
private 类{}中
默认的 包中
protected 包中和包外的子类
public 项目中

3.方法重写
1.条件

2.调用

3.什么情况下使用

4.自动转型
byte b = 10;
int i  = b;

学生表示大学生。
继承关系

父类 对象名 = new 子类构造方法();

5.多态
对象之间的多态性

6.接口
定义接口的关键字是interface
格式
public interface 接口名   extends 接口,... {
//常量
public static final 数据类型 常量名 = 值;

//抽象方法
public 返回值数据类型 方法名(数据类型 参数名,...);
}
注意四点：

类去实现接口的关键字是：implements
public class 类名 extends 类名或者抽象类 implements 接口名,... {
//实现(重写)父接口中所有的抽象方法
}

接口和类的区别：


7.抽象类
定义抽象类的关键字：abstract class
格式：
public abstract class 抽象类名  extends 类名或者抽象类  implements 接口名,... {

//类中所有的属性和方法

//接口中的常量和抽象方法
public abstract 返回值数据类型 方法名(数据类型 参数名,...);

}
总结：
听课、看书，再查网络资料，我对类继承的理解如下：
1、Animals.java
/**自定义类名用 大写+小写形式Animals
* 方法的参数全部用小写，单词之间用下划线分割animal_weight
* 类变量用大写+小写形式AnimalName
*
*/
/**
* @author Administrator
*
*/
public class Animals {

public String AnimalName;
public float AnimalWeight;

//私有属性不可被继承，但可以利用继承的方法取得
private String AnimalClaseName = "动物";

//本类的构造方法，初始化类变量
Animals(String animal_name,float animal_weight)
{
    AnimalName = animal_name;
    AnimalWeight = animal_weight;
 
}

Animals(){
 
    this("名字未定",0);
}

//一个方法，用于获取私有属性值；
public String GetAnimalClassName()
{
    return AnimalClaseName;
}

//一个方法，动物行为
public void    Sleep()
{
 
    System.out.println(AnimalName + "要睡觉了！");
}

//终结方法，不可以被子类重载（不可被子类重新声明的方法）
//可以防止子类对父类方法的错误重写，增加代码的安全性和正确性
//还可以提高运行效率：java编译器将该方法的可执行代码字节码直接放到调用它的程序中
final void Dead() {
    System.out.println("终结了，父类Over后，不可被子类重载");
 
}
}
//Fish 类继承Animals类的属性和方法
class Fish extends Animals {
 
    String FishColor; //子类声明鱼的特有属性
 
    //可以重新声明父类的变量名相同的变量，称为覆盖，隐藏父类的属性。调用方法super.weight
 
    //构造方法，初始化变量；
    //有继承时的构造方法，可以重载，但不可以从父类继承！
    /*1、子类不能从父类继承构造方法；
     * 2、好的程序应该是：在子类构造方法中[调用]父类构造方法；
     * 3、super关键字，用户调用父类的构造方法，
     * 4、子类构造方法中没有声明调用父类的构造方法时，
     * 则系统执行子类构造方法时自动调用父类默认的构造方法（即自动调用父类中无参的构造方法）
     * */
    Fish(String fish_name,float fish_weight,String fish_color){
     //如果不明确调用父类的构造方法，系统自动调用父类默认的无参构造方法；
     //super(fish_name,fish_weight);  
     //此时，即使创建对象：Fish fs = new Fish("扁口鱼",2,"黄色"); 动物名称也是“名字未定”
  
     //super();//这是默认的
  
     //子类构造方法显式调用父类有参构造方法，用于子类对象的初始化；
     super(fish_name,fish_weight);
  
     FishColor = fish_color;
  
  
    }
 
    //再写一个无参的构造方法
    Fish(){
  
     this("鱼名未定义",0,"颜色未定义");
    }
 
    Fish(String fish_color){
  
     FishColor = fish_color;
    }
 
    public void GetFishInfo(){
     //获取父类的私有变量;
     System.out.print("\n我是" + super.GetAnimalClassName()+ "\n");
  
     System.out.println("我是鱼："+    super.AnimalName + "重量:" + super.AnimalWeight + "颜色：" + this.FishColor );
  
  
    }
 
    //子类也可以定义和父类相同的行为（方法）,重新定义Sleep方法，覆盖了父类的Sleep方法！称为方法的覆盖。
 
    public void Sleep(){
     System.out.println("鱼也要睡觉么？我是：" + super.AnimalName );
  
     //子类调用父类被覆盖的方法。
     System.out.print("\n父类被覆盖的方法为：" );
     super.Sleep();
     System.out.println("\n" );
    }
 
    /*
    void Dead(){
     System.out.println("本方法在父类已经定义成终结方法，不能覆盖父类的终态方法！");
  
    }*/
 
}
---------------------------
2、AnimalsTester.java

public class AnimalsTester {
public static void    main (String[] args){
 
    Animals an = new Animals();
    System.out.println("动物1名字：" + an.AnimalName );
    System.out.println("动物1重量：" + an.AnimalWeight    );
 
 
    Animals an2 = new Animals("老虎",100);
    System.out.println("动物2名字：" + an2.AnimalName );
    System.out.println("动物2重量：" + an2.AnimalWeight    );
     an2.Sleep();
 
    Fish fs = new Fish("扁口鱼",2,"黄色");
     System.out.println("鱼名：" + fs.AnimalName );
     System.out.println("鱼重：" + fs.AnimalWeight    );
     System.out.println("鱼颜色：" + fs.FishColor    );
     System.out.println(fs.GetAnimalClassName());
     fs.GetFishInfo();
     fs.Sleep();
  
     //dead方法是父类的方法，可被继承,不可覆盖
     //
     fs.Dead();
  
}
}
--------------------------
3、运行结果：
动物1名字：名字未定
动物1重量：0.0
动物2名字：老虎
动物2重量：100.0
老虎要睡觉了！
鱼名：扁口鱼
鱼重：2.0
鱼颜色：黄色
动物
我是动物
我是鱼：扁口鱼重量:2.0颜色：黄色
鱼也要睡觉么？我是：扁口鱼
父类被覆盖的方法为：扁口鱼要睡觉了！

终结了，父类Over后，不可被子类重载