-->继承
1.继承的定义
--继承是一种由已有类创建新类的机制。在Java中，被继承的类称为基类或者父类，由继承形成的类称为派生类或者子类。
2.继承的特点
1.只支持单继承，即一个子类只允许有一个父类。
2. 子类可以拥有父类的属性和方法
3. 子类可以拥有自己的属性和方法
4. 子类可以重写覆盖父类的方法
5. 可以声明父类，创建子类（又称父类装载子类）
3.继承的应用
--Java中，一个类只能有一个父类，即类的单继承，使用extends关键字，这个类，称为派生类或子类。代码如下：
[修饰符] class 类名 [extends 父类] {
//派生类继承基类中非private的成员！！！
//派生类还可以实现变量的隐藏；
//派生类还可以实现方法重写。
}-对象的上转型
--定义：父类声明的对象，由其子类的构造方法构建。
代码如下：
public class Phone {
private String number;
public Phone() {
super();
//TODO Auto-generated constructor stub
}
public String getnumber() {
return number;
}
public void SetNumber(String number) {
this.number = number;
}
public void callup(String num) {
System.out.println("calling the"+num);
}
phones[1].setNumber("13546758769");
phones[2].setNumber("13546756369");
phones[0].setNumber("13546327659");
for (int i=0;i<phones.lenth;i++){
phones[i].callup("10086");
phones[i].acceptCall();
}
}
}-特点
1.对象的上转型，不能再调用子类特有的成员。
2.对象的上转型，只能调用子类重写的方法。
3.对象的上转型，实现了多态性！
-->抽象类
1.抽象的定义
--抽象是由abstract修饰的类，就是抽象类。抽象类只用于继承，不能用于创建对象。
2.抽象的特点
--抽象类中可以有成员变量、构造方法、实例方法，与普通类一致；
抽象类中还可以有抽象方法。
3.抽象的应用
--抽象类的派生类，必须重写所有的抽象方法！
ps：什么是抽象类方法
--方法：由abstract修饰的方法，就是抽象方法
--特点：抽象方法只能声明，不能实现
--应用：含有抽象方法的类，必须是抽象类；抽象类的子类，必须重写抽象方法。
>代码如下：
public abstract class AbstractClass {
private int x=100;
public void show()
{
System.out.println("抽象类中可以有成员变量："this.x);
}
public abstrac void say(); //抽象方法只能声明不能实现
}
public class SubClass extends AbstractClass {
public void say(){
System.out.println("抽象类的子类必须重写抽象方法");
}
}4.抽象类的位置
--1.用来规划子类都应该有哪些成员；
--2.在Java体系中，抽象类一般都是最高的基类。例如IO流
5.抽象类的应用
>代码如下:
public abstract class Shapes {
/**
*定义抽象类Shapes图形类，包含抽象方法getArea()、getPerimeter();
**/
public abstract double getArea(); //获取面积
public abstract double getPerimeter(); //获取周长
}
public class Circle extends Shapes {
double r;
public Circle(double r) {
this.r = r;
}
public double getArea() {
return r*r*Math.PI;
}
public double getPerimeter() {
return 2*Math.PI *r;
}
}-->接口
1.接口的定义
--由于Java中并不允许多置继承，但Java提供了接口（interface）来解决这类问题。
接口是用来实现类似多置继承功能的一种结构，它在语法上和类很相似，也有成员变量和方法，接口间也可以形成继承关系，但接口和类有着很大的区别，它的成员变量都是常量，方法都是抽象方法，没有方法体。
>代码如下：
[修饰符] <interface> <接口名> [extends 父接口列表]
{
[public] [static] [finall] 类型 变量名=初始值; //静态常量
[public] [abstract] 返回值 方法名 ([参数列表])； //抽象方法
}2.接口的特点
1.接口用关键字interface来定义，而不是class。
2.接口中定义的变量全部公有的、静态的、最终的，所以都是常量。
3.接口中定义的方法都是抽象、公有的、所以修饰符可以省略。
4.接口中没有构造方法，而且定义的方法都是抽象方法，所以接口不能创建对象。
5.接口采用多重继承机制，而不是采用类的单重继承机制。
3.接口的应用
--一个类要实现某个或某几个接口的使用implements关键字。
一个类可以同时实现多个接口，各接口间用“，”隔开。这个类，称为接口的实现类。
>代码如下：
[修饰符] class 类名 [extends 父类] implements 接口1，接口2，接口3 {
//类体一定要重写接口中的所有方法！！！
}应用：
使用了接口实现类，必须重写接口中所有的方法！！！
接口回调：
接口声明的对象，由其实现类的构造方法构建。
>如下代码：
public interface Jumpping {
public abstract void jump(); //相当于void jump;
}
public class Cat implements Jumpping {
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
}
public class Dog implements Jumpping {
@Override
public void jump() {
System.out.println("狗狗跑得快，跳的不高");
}
}
//测试类，或接口类
public calss JumppingDemo {
public static void main(String[] args) {
// Jumpping j = new Jumpping(); //错误，接口不能实例化
Jumpping j1=new Cat(); //接口回调！！实现的是多态性
Jumpping j2=new Dog();
j1.jump();
j2.jump();
}
}4.接口和抽象类的区别
1.接口中的所有方法都是抽象的，而抽象类可以有抽象方法，也可以有实例方法。
2.一个类可以实现多个接口，但只能继承一个父类，接口可以继承多接口。
3.接口与实现它的类不构成继承体系，即接口不是类体系的一部分。因此，不相关的类也可以实现相同的接口，而抽象类是属于类的继承体系，并且一般位于类体系的顶层。
-->内部类
1.内部类的定义
--将一个类定义在另一个类的内部，即为内部类，另一个即为外部类。
2.内部类的特点
1.内部类创建对象的方式不一样；
2.内部类生成的字节码不一样。
3.内部类的功能
实现类的多重继承：
实例如下：
public class OuterClass {
int x=100;
class InnerClass{
int x=55;
public void display(){
System.out.println("内部类的方法,x="+x);
}
}
public void display() {
System.out.println("内部类的方法,x="+x);
}
}
class Demo {
public static void main(String[] args) {
OuterClass ob1=new OuterClass();
ob1.display();
OuterClass.InnerClass ob2=new OuterClass().new InnerClass();
ob2.display();
}
}--生成的字节码文件如下：
Demo.class
OuterClass$InnerClass.class
OuterClass.class
