Java的继承

Java的四大特征：封装，继承，多态，抽象
继承是面向对象的最显著的特征之一，多态以继承为基础.继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
首先举一个简单的继承实例:

public class student{  string name;  int age;  void eat();  void drink();  void learn();}public class teacher{   string name;   int age;   void eat();   void drink();   void teach();}public class people{   string name;   int age;   void eat();   void drink();}

由上面的代码可以看出代码的重复率很高，people的特征在teacher和student中都用到了，这时候就为了减少代码的重复，就需要用到我们今天所说的继承。

   public class student extends people    {      void learn();    }    public class teacher extends people    {       void teach();    }    public class people    {       string name;       int age;       void eat();       void drink();    }

这样就减少了很多的麻烦。
**接下来我们就着重的讲一下继承的方法
继承里面不是所有形式的类都能被其他类，子类，外包可以访问到的，他们都有自己的权限。如同C++一样，public全部能访问，private 除了类里面的的全部不能访问。
当前 类 包 子类 外部包
public ok ok ok ok
protected ok ok ok
默认 ok ok
private ok
接下来讲一些继承所涉及的关键字
Final关键字：
当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
Object 类
Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。在不明确给出超类的情况下，Java会自动把Object作为要定义类的超类。可以使用类型为Object的变量指向任意类型的对象。Object类有一个默认构造方法pubilc Object()，在构造子类实例时，都会先调用这个默认构造方法。Object类的变量只能用作各种值的通用持有者。要对他们进行任何专门的操作，都需要知道它们的原始类型并进行类型转换。
Super关键字
在JAVA类中使用super来引用父类的成分，用this来引用当前对象，如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢？使用super来引用，this指的是当前对象的引用，super是当前对象里面的父对象的引用。

package cn.zjm.test;/** * 父类 * @author gacl * */class FatherClass {    public int value;    public void f() {        value=100;        System.out.println("父类的value属性值="+value);    }}/** * 子类ChildClass从父类FatherClass继承 * @author gacl * */class ChildClass extends FatherClass {    /**     * 子类除了继承父类所具有的valu属性外，自己又另外声明了一个value属性，     * 也就是说，此时的子类拥有两个value属性。     */    public int value;    /**     * 在子类ChildClass里面重写了从父类继承下来的f()方法里面的实现，即重写了f()方法的方法体。     */    public void f() {        super.f();//使用super作为父类对象的引用对象来调用父类对象里面的f()方法        value=200;//这个value是子类自己定义的那个valu，不是从父类继承下来的那个value        System.out.println("子类的value属性值="+value);        System.out.println(value);//打印出来的是子类自定义的那个value的值，这个值是200        /**         * 打印出来的是父类里面的value值，由于子类在重写从父类继承下来的f()方法时，         * 第一句话“super.f();”是让父类对象的引用对象调用父类对象的f()方法，         * 即相当于是这个父类对象自己调用f()方法去改变自己的value属性的值，由0变了100。         * 所以这里打印出来的value值是100。         */        System.out.println(super.value);    }}/** * 测试类 * @author gacl * */public class TestInherit {    public static void main(String[] args) {        ChildClass cc = new ChildClass();        cc.f();    }}

强制转换
people p1=new student();
Student s1=(Student)p1;
p1.study()
输出s1和p1,输出相同地址。
强行转化之前要判断

if（p1 instanceof Student){           //强行转化语句}else//不能进行强制转化{}

特殊强制转化

ArrayList list1=new ArrayList();List list2=new ArrayList();

匿名类

匿名类是不能有名字的类，它们不能被引用，只能在创建时用New语句来声明它们。匿名类的声明是在编译时进行的，实例化在运行时进行，这意味着for循环中的一个new语句会创建相同匿名类的几个实例，而不是创建几个不同匿名类的一个实例。
匿名类的目的是在某个地方需要特殊的实现，因此在该处编写其实现，并获取它的实例，调用它的方法。不要在匿名内部类编写其他的方法，是不可见的。
形式为：new <类或接口> <类的主体>

public class TestAnonymousClass{　　public static void main(String args[]){　　TestAnonymousClass testAnonymousClass=new TestAnonymousClass();　　testAnonymousClass.show();　　}　　//在这个方法中构造了一个匿名内部类　　private void show(){　　Out anony=new Out(){ // 获取匿名内部类实例　　void show(){ //重写父类的方法　　System.out.println("this is Anonymous InterClass showing.");　　}　　};　　anony.show();// 调用其方法　　}　　}　　// 已有类Out；匿名内部类通过重写其方法获得另外的实现　　class Out{　　void show(){　　System.out.println("this is Out showing.");　　} [1] 　　}

构造方法

public class qi{}class qii{}

一个Java文件只能定义一个public类
一个类编译出一个字节码文件
可以放在都public 内部，输入内部类
继承好处
首先代码达到重用的目的
Student s=new people()错误
people p1=new Student()正确
people p1=new teacher()正确
//子类实体指向父类引用
Student s=new Student()

只有拿到内存才改变，达不到内存就办法就可以改变值
值传递：基础数据类型(boolean,char,byte,short,int,long,double,float)
引用传递：复杂数据类型（引用型数据类型）
数据保存方式不同。
这就是Java的继承。