继承&多态

继承：

概念：

基类，超累，父类

访问权限：

Public ：无限制，自由访问

Private：不可继承

protected ：包内，包外，可访问，继承

default：没有指明任何权限下，默认在同一包内，可访问

构造方法：

子类调用父类构造方法

Super(参数)；//必须为子类构造方法的第一句。！！

原因：在创建子类对象时，先要构造父类，也就是初始化子类先初始化父类。在继承下，没有构造父类，就没有子类，会抛出异常。Java虚拟机一般会默认构造父类（初始化父类）。

Final-不可继承的类

Final声明的变量不可更改；

Final声明的方法不可覆盖（重写）；

Final声明的类不可继承，只读。

子类与父类方法的联系

1扩展：增加父类没有的方法

2覆盖（重写）：同名同参。不能覆盖final，static的方法

3重载：同名不同参。

例

分析：fruit继承了object类，并重写了toString()方法。在“+”后引用一个对象名，系统默认会调用toString（）方法。此方法返回“类名 @ + hashCode”。

多态

***

父类（或接口）对象可引用子类（实现接口的类）对象

***

1子类可以给父类赋值；

Class Animal{}

Class Dog extends Animal{}

Animal an=new Dog();//可以

2父类要强制转换后给子类赋值；

3可以用instanceof运算符判断对象是否可以转换

Object obj instanceof String;true or fause;

例1：

Class Animal{}

Class Dog extends Animal{}

Class Cat extends Animal{}

Animal an=new Animal();

Dog dog=new Dog();

Cat cat=new Cat();

an=dog;//对

dog=an;//错

dog=(dog)an;//对

dog=cat;//错

dog=(dog)cat;//错，Cat和Dog两个类没有继承关系

例2：子类父类相互调用变量方法

class father1{

public int num=100;

public void show() {

System.out.println("father."+num);

}

}

class son extends father1{

public int num=200;

public void show() {

System.out.println("son."+num);

}

}

public class Father {

public static void main(String args[]) {

son s=new son();

father1 fa1=new father1();

father1 fa2=new son();

fa1.show();//自己的方法

s.show();//子类自己的方法

fa2.show();//引用子类对象，调用子类的方法

fa1=s;//子类赋给父类对象，调用子类方法

fa1.show();

fa1.num++;//父类字段改变

System.out.println(fa1.num);

fa1.show();

((son)fa1).num++;//改变子类字段

System.out.println(fa1.num);

fa1.show();//改变了子类的变量

}

}

总结：

1；子类与父类有相同的方法时；子类对象用自己的（相当于子类重载了父类的同名方法），父类对象调用自己的方法。父类引用子类对象时调用子类的方法。

2：子类与父类有同名的字段（变量）时；父类用父类的，子类用子类的（子类的变量会隐藏或代替父类变量，如果要调用父类变量时可以用super）。

3((son)father).num++;改变了子类的变量；先将父类对象转换为子类对象，后改变子类变量。

例3：

import java.util.Vector;

class Animal{

public void eat() {

System.out.println("");

}

}

class Lion extends Animal{

public void eat() {

System.out.println("肉");

}

}

class Monkey extends Animal{

public void eat() {

System.out.println("香蕉");

}

}

class Bird extends Animal{

public void eat() {

System.out.println("米");

}

}

public class Feeder {

public void feed(Vector<Animal> v) {

for(Animal an:v) {

an.eat();

}

}

public static void main(String[] args) {

Feeder feeder=new Feeder();

Vector<Animal>temp=new Vector();

//加一个狮子

temp.add(new Lion());

//加2个猴子

for(int i=0;i<2;i++) {

temp.add(new Monkey());

}

//加3个鸟

for(int i=0;i<3;i++) {

temp.add(new Bird());

}

feeder.feed(temp);

}

}

结果截图：

多态编程两种主要形式

1：继承多态。例3

2：接口多态。使用接口代替抽象基类。

抽象abstract---------------------------多态&继承

例

Abstract class ASS{

Public void show（）{
}

}

三种类型：

1. 直接定义了一个抽象类

2. 继承了一个抽象类，但没有完全实现父类方法（必须实现所有方法）

3. 实现了一个接口，但没有完全实现此接口中的方法

创建对象：

抽象类不能直接创建对象

可引用子类对象。

例1：

abstract class ab1{

public void show(int a) {

}

}

abstract class ab2 extends ab1{

public void showw(float f) {

}

}

class ab3 extends ab2{

public void show(int a) {

System.out.println("1-"+a);

}

public void showw(float f) {

System.out.println("2-"+f);

}

}

public class Abstractx {

public static void main(String args[]) {

ab3 xx=new ab3();

xx.show(1);

xx.showw(11);

ab2 x=new ab3();

x.showw(2);

x.show(3);

ab1 xxx=new ab3();

xxx.show(4);

//xxx.showw(11);错，ab1类中没有showw()方法

}

}

例2：

abstract class Animal2{

public void show() {

}

}

class Cat extends Animal2{

public void show() {

System.out.println("喵");

}

}

class Dog extends Animal2{

public void show() {

System.out.println("汪");

}

}

public class Abstractx {

public static void main(String args[]) {

Animal2 x=new Cat();

x.show();

Animal2 xx=new Dog();

xx.show();

}

}

接口（不是类）

定义：Interface，实现：implements

（自动的）成员变量：static ，final，成员方法：public

接口可以继承接口

例：

interface Face1{

void show();

void show2();

void show3();

}

class Achieve implements Face1{

public void show() {

System.out.println("show");

}

public void show2() {

System.out.println("show2");

}

public void show3() {

}

}

public class InterFace1 {

public static void main(String args[]) {

Achieve ac=new Achieve();

ac.show();

ac.show2();

Face1 face=new Achieve();

face.show();

face.show2();

}

}