继承：
概念：
基类，超累，父类
访问权限：
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();
}
}