第七节 继承和派生-super的两个用法 关键词final

一.super的用法

1.super与构造函数

class Phone{
String color;
Phone(String color )
{ this.color=color; }//这是一个有参的构造方法
}

class IntelligentPhone extends Phone{
IntelligentPhone ()
{super("红色");}  
}

}
class  Test{
public static void main(String args[]){
IntelligentPhone  p=new IntelligentPhone();}
}

 执行顺序：先执行父类构造方法，再执行子类构造方法。在多层继承层时，编译器会一直上溯到最初类，再从“上”到“下”依次执行。

如果在子类中未显式调用父类构造方法，则编译器会自动调用父类的默认构造方法，假若父类没有提供默认构造方法，编译时将出错。

解决方法

1、在父类添加一个无参的构造方法。 2、在子类中显示的调用父类的有参构造方法。

父类的构造方法不能继承

super()  显示调用父类的构造方法

1.只能在子类的构造方法中调用，普通方法不能调用  

2.它必须是子类构造方法的第一条语句

3.如果调用了super(),只能调用一次     子类调用父类的构造方法

2.使用super访问父类被子类隐藏的成员

class Phone{
String color="黑色";String  name="小米";
String  getName()  {return  name;}
}
class IntelligentPhone extends Phone{
String color="绿色";String  name="NOTE8";
String  getName()   {return  name;}
String printColor()
 { System.out.println(super.color);}//可以利用super调用父类的属性和方法
String printName()
 { System.out.println(super.getName());}
}

继承的概念 子类对象

super关键字

1.super.变量或super.方法()

2.在子类构造方法中调用父类的构造方法
代表父类的对象引用

二.super和this

class Person { 
   String name;
   int age;
    Person() {   }    
    Person(String name) 
  {  this.name=name;  }
  Person(String name,int age) 
  { this("王二");
     this.age=age  ;}
}
public class Chinese extends Person {  
String sno;
Chinese() {  super();    }     Chinese(String name,int age,String sno) {   super(name);    super.age=age;    this.sno=sno; }    
    public static void main(String[] args)   { Chinese cn = new Chinese(); 
cn = new Chinese("codersai", 18,"2018"); 
   } 
}

二.final

1.final描述成员变量

final 修饰类中的成员变量 表示该属性一旦被初始化便不可改变（常量），这里不可改变的意思对基本类型来说是其值不可变，而对对象属性来说其引用不可再变，引用空间的值是可以改变的。

public class B {
    final int count = 1;
    public int updateCount() {
        return count;    }
    public final int sum() {
        int number = count+10;
            return number;    }}}

public class B {
    final int count ;
   public B() {count=1;}
    public int updateCount() {
        return count;    }
}

1.1fianl修饰属性必须初始化，初始化 只能在初始化可以在两个地方： 一是其定义处、二是在构造函数中

1.2如果在其定义处已初始化，在构造函 数中初始化变量会报错。

1.3不能修改final描述的基本类型的值

1.4不能修改final描述的引用类型的， 或者指向内存的空间，但可以修改 其指向的空间的内部值

并且也不允许任何从此类继承的类来重写这种方法，但是继承仍然可以继承这个方法

2.final描述成员方法

3.final描述类

先执行父类的构造方法

java引用对象的两个类型：

编译时类型：由声明该变量时使用的类型

运行时类型：由实际赋给该变量的对象决定

如果编译时类型和运行时类型不一致  ：多态、

class A{
    int a=10;
    static int b=10;
public void f1(){System.out.println("我是父类的f1方法");}}
class B extends A{
    int a=100;
    static int b=100;
    public void f1()    {System.out.println("我是子类的f1方法");}
    public void f2()    {System.out.println("我是子类的f2方法");}
}
public class TEST{
    public static void main(String[] args){
         B B1 = new B();
        System.out.println(B1.a);
        System.out.println(B1.b);
        B1.f1();
        B1.f2();
    }
}

一.对象的上转型

public class TEST{
    public static void main(String[] args){
  /*B B1 = new B(); */         A B1 = new B(); 
   
}
}

 因为子类其实是一种特殊的父类，因此Java允许把一个子类对象直接赋给一个父类引用变量，无须任何类型转换，或者被称为向上转型,向上转型由系统自动完成。 例如：父类  对象名称=new  子类()

Java引用变量有两个类型：编译时按照父类对象看待，一个是运行时实际是子类对象。

二.对象的下转型

public class TEST{
    public static void main(String[] args){
            A A1=new B();
    	     B B1 = (B)A1;
            B1.f2();      


       /*B A1 = (B)new A(); */
}
}

三.对象的多态

多态的前提条件

1.子类继承父类

2.子类重写父类方法

3.父类引用指向子类对象

多态的成员特点：。         当你用父类引用指向子类对象的时候，         1、成员变量不变，调用结果为父类的成员变量的值         2、成员方法改变，调用结果为子类的成员方法的结果         3、静态成员方法不变，调用的结果为父类的静态成员方法         引用成员之间的转换：         向上转型：子类转换成父类  由小到大   基本数据类型的自动类型转换         向下转型：父类转换成子类  由大到小   基本数据类型的强制类型转换