黑马程序员—— 5,继承，子父类，抽象类，接口，final，模板设计

  -----------android培训、java培训、java学习型技术博客、期待与您交流！------------             

黑马程序员——  5,继承，子父类，抽象类，接口，final，模板设计

一：继承----》

/*
以下是继承的例子
继承是在类和类之间有关系的时候用extends表示
JAVA中仅仅支持单继承，不支持多继承：因为多个父类有相同功能但是功能内容不同时，子类对象无法确定执行哪个
JAVA支持多层继承，多实现（A继承B，B继承C）
参阅父类功能，建立子类对象使用功能
此外，还有几种概念需要区别：
继承：谁是谁的一种
聚集：谁里面有谁
聚合：球员与球队的关系（联系较为松）
组合：手脚是身体一部分（联系较为紧密）
 
*/
class Dongwu  //动物类
{
         String  wuzhong;//动物的物种
         int     age=10;//动物的年龄
         private  int age1=56;
         int      leg=4;
         Dongwu()
         {
              System.out.println("动物类的构造函数");
         }
         Dongwu(int   leg)
         {
            this.leg=leg;
         }
         void    yudong()
         {
               System.out.println("跳跃");
         }
         void  chi()//吃的行为
         {
            System.out.println("吃东西");
         }
}
class    Dog extends Dongwu//狗类继承动物类
{
         int   age=14;
         Dog()
         {
                   //super();即便这句话不写，虚拟机也会自动默认在第一行加上
                    System.out.println("狗类的构造函数");
                   /*
                      在虚拟机运行的时候，会先执行动物类（父类）的构造函数；
                      再执行狗类（子类）的构造函数。
                      子类的所有构造函数都会默认访问父类中的空参数构造函数
                      当父类中没有构造函数时候，子类必须手动通过super或者this指定要访问的构造函数。
                      子类的构造函数的第一行也可以用this来访问本类的构造函数。
 
 
                   */
         }
         Dog(intx)
         {
            //super();即便这句话不写，虚拟机也会自动默认在第一行加上
            //所以，子类一定会访问父类的构造函数
             System.out.println("自己想要设定狗的年龄是"+x);
           
         }
   void  jiao()
   {
                    System.out.println("汪汪汪+年龄"+this.age);//这句话打印的是“汪汪汪+年龄14”
                   System.out.println("汪汪汪+年龄"+super.age);//这句话打印的是“汪汪汪+年龄10”
                   //this表示本类对象的引用；super表示父类对象的引用
        /*
                    System.out.println("汪汪汪+年龄"+super.age1);
                    这句话会出错，因为age1是父类的私有成员
         */
                  System.out.println("汪汪汪+腿"+this.leg);//这句打印的是"汪汪汪+腿4"
                   /*
                   因为Dog类继承了父类，就有了父类的成员
                   */
 
   }
}
 
class  Cat extends Dongwu//猫类继承动物类
{
         Cat(intn)
         {
             super(n);//子类方法需要父类构造函数，也是用super调用
         }
    void  jiao()
   {
       System.out.println("喵喵喵");
   }
 
  void yudong()//子类与父类有同名函数，这就出现了覆盖（返回类型和参数列表都必须要一模一样）
   //覆盖必须要子类权限大于等于父类权限，静态只能覆盖静态
   {
        System.out.println("猫的跳跃"); 
   }
  void method()
   {
            super.chi();//子类的方法需要父类的方法，直接用super调用
   }
}
class   Jicheng
{
         public  static void main(String[] args)
         {
                   Doga=new Dog();
                   a.jiao();
                   System.out.println("HelloWorld!");
         }
}

二：final----》

这个final是一个修饰符，可以修饰类，函数，变量，

被final修饰的类不可以被继承；final类里面的方法默认被final修饰

被final修饰的函数不可以覆盖；

被final修饰的变量只可以赋值一次，之后其值便固定下来不会变化；

这就可以用于一些固定值，这些固定值要用英文大写，多个词语的组合就用下划线分开，例如：

这个例子final  double MY_PI= 3.14;

//抽象用abstract修饰
/*
抽象类不能够建立对象；
子类复写掉父类中所有的抽象方法才可以建立子类对象；
如果子类没有覆盖掉父类的所有抽象方法，子类还是抽象类
抽象只能够修饰方法和类；
抽象类可以没有抽象方法，这种作用是强制该类不能够建立对象
*/
abstract class Dongwu//类中只要有抽象方法，该类就是抽象类
{
         abstract   void shout();//抽象方法,没有定义具体内容的方法
void  chi()
{
    System.out.println("吃东西");
 
}
 
}
class Dong extends Dongwu//狗类继承动物类
{
   void shout()//叫喊的行为
         {
             System.out.println("汪汪汪");
         }
}

三：模板设计方式----》

/*
模板方式模式
模板方法：定义功能时候，一部分确定，另外一部分不确定；
把不确定部分暴露，由子类去覆盖
*/
abstract class Dongwu
{
        public   final   void   eattime()//用final把这个方法固定下来不可以更改覆盖
         {
                    long a1=System.currentTimeMillis();//获取开始时间
                    eat();
                    long a2=System.currentTimeMillis();//获取结束时间
                    System.out.println("吃饭时间是"+(a2-a1));
     
         }
        //public void eat(){}空的方法，没有实际内容，但是这个不是抽象方法
         public  abstract void eat();//这个就是抽象类
 
}
class   Dog   extends   Dongwu
{
         public   void eat()
         {
             for(int b1=0;b1<=9;b1++)
                   {
 
                      System.out.println(b1);  
                   }
         }
 
}
class   Moban
{
         public   static   void   main(String[] args)
         {
                   Doga= new Dog();
                   a.eattime();
 
                   System.out.println("HelloWorld!");
         }
}

四：接口----》

/*
接口的介绍
特殊的抽象类
抽象类中所有的方法都是抽象的，那么这就定义成接口的形式
接口用interface定义：
*/
interface   Dongwu//编译成功后，接口也会生成一个类文件，所以把其看做是一个特殊抽象类就可以了
 
{
         public   static   final int leg=4;//接口常量定义：public static final
         publicab  stract void shout();//接口方法定义：publicabstract
 
}
interface   Maoke//猫科接口
{
   public  static  final int leg=4;
   publicab   stract void eat();
}
class Cat1
{
    public  void sleep()
          {
         System.out.println("猫在睡觉");       
          }
 
}
class Dog implements Dongwu//狗类实现动物类
{
         public  void shout()
         {
             System.out.println("汪汪汪");
         }
}
class Cat extends  Cat1 implementsDongwu,Maoke//一个类可以在继承父类的同时也可以多实现
 
{
         public  void shout()
         {
              System.out.println("喵喵喵");
         }
         public  void eat()
         {
         System.out.println("猫在吃东西");
         }
}
class Jiekou
{
         public static void main(String[] args)
         {
                   Doga=new Dog();
                   a.shout();
                   System.out.println(a.leg);//打印的是4
                   System.out.println(Dongwu.leg);//打印的是4
                   System.out.println(Dog.leg);//打印的是4
         }
}

/*
关于接口的一些细节，关于接口与接口之间可以多继承
利用生物分类的例子解释
接口与类的用法区别也有一个：类主要用于体系中，接口用于功能扩展。
*/
interface Renke//人科接口
{
    public abstract void paxing();//抽象爬行方法
}
interface Renshu//人属接口
{
     public abstract void zoulu();//抽象走路方法
}
 
interface Renzhong extends Renke,Renshu//人种接口继承人科接口和人属接口
{
     public abstract void sikao();//抽象思考方法
}
class Renlei implements Renzhong
{
         public  void paxing(){}
         public  void zoulu(){}
         public  void sikao(){}
 
}
 

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------