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的继承。