潭州Java中级班（day_12）Super关键字，final关键字，抽象类，接口，Object类

知识点

1.super关键字

2.final关键字

3.抽象类

4.接口

5.Object类

一.super

super: 关键字父类的
* this : 关键字什么什么的代表本类对象的哪个对象调用然后就代表哪个对象。
*
* this:
* 1.调用成员变量
* 2.调用成员函数
* 3.调用构造函数,只能在第一行
*
* super:
* 1.调用成员变量
* 2.调用成员函数
* 3.调用构造函数,只能在第一行
*
* 构造函数特点：
* 1.子类构造函数，默认会调用父类空参数的构造函数（肯定会调用，除非你调用了别的构造函数）。

/**
 * 这个类是讲述super
 * @ClassName:     Demo6Super.java
 * @Description:   TODO  
 * @author         Jim老师 
 * @version        jdk8.0  
 * @Date           2018年8月30日   下午8:11:41 
                     无敌是多么的寂寞
                     男人不能说不行，不行也得行
 */
/*
 * super:  关键字     父类的
 * this :  关键字      什么什么的       代表本类对象的   哪个对象调用然后就代表哪个对象。
 * 
 * this:
 *     1.调用成员变量
 *     2.调用成员函数
 *     3.调用构造函数,只能在第一行
 *     
 * super:
 *     1.调用成员变量
 *     2.调用成员函数
 *     3.调用构造函数,只能在第一行
 * 
 * 构造函数特点：
 *    1.子类构造函数，默认会调用父类空参数的构造函数（肯定会调用，除非你调用了别的构造函数）。
 */
class    Writer1{
       String     fileName="a.txt";
       public   void    write(){
              System.out.println("父类写");
       }
}
class   FileWriter1   extends    Writer1{
       String     fileName="b.txt";
       public   void    write(){
              System.out.println("子类写");
       }
       public   void show(){
//              System.out.println(this.fileName);  //默认是自己的,这里是省略了this
              System.out.println(super.fileName);//调用父类的
              
              write();                           //自己的，它会自己添加this
              super.write();
       }
}
public class Demo6Super {
       
       public static void main(String[] args) {
//                FileWriter1    fileWriter1=new   FileWriter1();
//                fileWriter1.show();
                
                
                test2();
                
       }
       public   static   void    test(){
                       FileWriter1    name=new   FileWriter1();
                        
                       /*                name=FileWriter1@659e0bfd
                        *              FileWriter1: 对象所属的类型   
                        *              @分割
                        *              659e0bfd：存对象的地址值（是十六进制的）
                        */
                           
                           System.out.println("name="+name);
                           
                           
                           Demo6Super    demo6Super=new   Demo6Super();
//                           Demo6Super@2a139a55
                           System.out.println("demo6Super="+demo6Super);
       }
       public    static  void   test2(){
                        new   Zi6(10);//3  4   1   2
       } 
       
}
class     Fu6{
         public   Fu6(){
                System.out.println("3.开大众，不怕奔驰和路虎，就怕大众有字母");
         }
         public   Fu6(int  a){
                this(); //
                System.out.println("4.开大众，不怕奔驰和路虎，就怕大众有字母");
         }
}
class    Zi6   extends   Fu6{
         public   Zi6(){
                 super(10);//
                 System.out.println("1.开宝马");
         }
         public   Zi6(int  a){
                 this();//
                 System.out.println("2.开兰博基尼");  
         }
}
//A  编译失败      B 2      C.32    D.运行失败

二.final关键字

final: 关键字最终的最后的
特点：
1.修饰类，类不可以被继承
2.修饰成员函数,函数不可以被覆盖重写复写
3.修饰成员变量,变量是常量。常量名的格式AAAA_BBBB_CCCC
4.修饰局部变量,变量也是常量。

/**
 * 这个类是讲述final关键字
 * @ClassName:     Demo7Final.java
 * @Description:   TODO  
 * @author         Jim老师 
 * @version        jdk8.0  
 * @Date           2018年8月31日   下午8:06:35 
                     无敌是多么的寂寞
                     男人不能说不行，不行也得行
 */
/*
 * final:  关键字    最终的   最后的
 * 特点：
 *    1.修饰类，类不可以被继承
 *    2.修饰成员函数,函数不可以被覆盖重写复写
 *    3.修饰成员变量,变量是常量。常量名的格式AAAA_BBBB_CCCC
 *    4.修饰局部变量,变量也是常量。
 */
final  class  Fu7{  }
//class   Zi7   extends   Fu7{}f
class    String1{
       public  final void   show(){}
}
class    ZiString1  extends   String1 {
//       public   void   show(){}
       final    int     NUM=10;
       public   void    test(){
//                num=11;
                
                final   int     AAAA_BBB_CCC=100;
//                aaaa_bbb_ccc=200;
       }
}
public class Demo7Final {
     public static void main(String[] args) {
           String    name="张三";    
           System.out.println("name="+name);
    }
}

三.抽象类

抽象类：用abstract修饰的类，就是抽象类。
* 抽象类的格式：
* public abstract class 类名{
*
* }
* 抽象方法：用abstract修饰的方法，就是抽象方法,没有方法体。
* 抽象方法的格式：
* public abstract 返回值类型方法名(形式参数类型1 参数名1,.....);
* 抽象类的特点：
* 1.抽象类不能new对象，有构造函数（子类要用）。
* 2.抽象方法没有方法体，是给子类实现具体的功能。
* 3.abstract不能跟static共存。
* 4.子类继承抽象类，要么自己为抽象类，要么去实现抽象类中的全部抽象方法。
* 5.抽象类可以有普通方法,可以有抽象方法。
* 6.有抽象方法的类一定是抽象类。

/**
 * 这个类是讲述抽象类
 * @ClassName:     Demo8AbstactClass.java
 * @Description:   TODO  
 * @author         Jim老师 
 * @version        jdk8.0  
 * @Date           2018年8月31日   下午8:22:18 
                     无敌是多么的寂寞
                     男人不能说不行，不行也得行
 */
/*
 * 抽象类： 用abstract修饰的类，就是抽象类。
 * 抽象类的格式：
 *     public    abstract   class     类名{
 *     
 *     }
 * 抽象方法：  用abstract修饰的方法，就是抽象方法,没有方法体。
 * 抽象方法的格式：
 *     public   abstract  返回值类型    方法名(形式参数类型1  参数名1,.....);
 * 抽象类的特点：
 *   1.抽象类不能new对象，有构造函数（子类要用）。
 *   2.抽象方法没有方法体，是给子类实现具体的功能。
 *   3.abstract不能跟static共存。
 *   4.子类继承抽象类，要么自己为抽象类，要么去实现抽象类中的全部抽象方法。
 *   5.抽象类可以有普通方法,可以有抽象方法。
 *   6.有抽象方法的类一定是抽象类。
 */
abstract   class   Animal8{
        public   Animal8(){
            
        }
        public  abstract   void   eat();
        public  void  play(){}
}
class    Pig8  extends   Animal8{
        @Override
        public void eat() {
            
        }
}
abstract  class    Cat8  extends   Animal8{}
public class Demo8AbstactClass {
        public static void main(String[] args) {
//                 new   Animal8();
        }
}

abstract   class    JavaStu{
      public   abstract  void  study();
}
class      JAVASEStu   extends    JavaStu{
    @Override
    public void study() {
           System.out.println("学习javase");
    }
}
class    JSPStu    extends    JavaStu{
    @Override
    public void study() {
        System.out.println("学习jsp");
    }
}

四.接口

接口：类与类之间是单继承，为了弥补这个缺点，所以实现了接口，为了程序的扩展。
* 接口可以理解一种特殊的抽象类，接口中的变量都是常量，接口中的方法都是抽象方法。
*
* 类的格式： public class Test{}
* 接口的格式：public interface Test{}
*
* 接口的特点：
* 1.接口中的方法都是抽象方法。默认添加public abstract
* 2.接口中的变量都是常量。默认会添加 public static final
* 3.类与接口是实现关系而且可以实现多个，类与类之间是继承关系(单继承)，接口与接口之间也是继承关系（多继承）
* 4.一个类实现接口，要么自己是抽象类,要么覆盖掉接口中的全部抽象方法。
* 5.接口不能创建对象

import org.omg.CosNaming.NamingContextExtPackage.AddressHelper;

/**
 * 这个类是讲述接口
 * @ClassName:     Demo9Interface.java
 * @Description:   TODO  
 * @author         Jim老师 
 * @version        jdk8.0  
 * @Date           2018年8月31日   下午8:55:27 
                     无敌是多么的寂寞
                     男人不能说不行，不行也得行
 */
/*
 * 接口：  类与类之间是单继承，为了弥补这个缺点，所以实现了接口，为了程序的扩展。
 *      接口可以理解一种特殊的抽象类，接口中的变量都是常量，接口中的方法都是抽象方法。
 * 
 * 类的格式：  public   class      Test{}
 * 接口的格式：public  interface   Test{}
 * 
 * 接口的特点：
 *      1.接口中的方法都是抽象方法。默认添加public   abstract
 *      2.接口中的变量都是常量。默认会添加  public   static   final
 *      3.类与接口是实现关系而且可以实现多个，类与类之间是继承关系(单继承)，接口与接口之间也是继承关系（多继承）
 *      4.一个类实现接口，要么自己是抽象类,要么覆盖掉接口中的全部抽象方法。
 *      5.接口不能创建对象
 */
class   FuArrayListtt{
    
}
interface   Collectionn{}
interface      ListList  extends   FuList,Collectionn{
          public   static   final  int     size=100;
          public   abstract   void    add();
}
interface     FuList{
    
}
class    ArrayListtt  extends   FuArrayListtt   implements    ListList,FuList{
        static    int   a=100;
        @Override
        public void add() {
        }
        public  static   void   show(){
               System.out.println(a);
               a=200;
               
               System.out.println(size);
//               size=200;
        }
}
public class Demo9Interface {
       public static void main(String[] args) {
//                  new    FuList();
                  String    name="魔笛";
    }
}

abstract    class   Fly{
       public   abstract  void   fei();
}
class    Superman   extends  Fly{
        public  void     fei(){
               System.out.println("超人飞");
        }
}
class    Bird extends  Fly{
        public  void    fei(){
               System.out.println("小鸟飞");
        }
}
class    Airplane  extends  Fly{
        public   void   fei(){
               System.out.println("飞机飞");
        }
}
class   Car    extends  Fly{
        public void    fei(){
               System.out.println("汽车飞");
        }
}

五.Object类

/**
 * 这个类是讲述Object类
 * @ClassName:     Demo10Object.java
 * @Description:   TODO  
 * @author         Jim老师 
 * @version        jdk8.0  
 * @Date           2018年8月31日   下午9:54:41 
                     无敌是多么的寂寞
                     男人不能说不行，不行也得行
 */
/*
 * Object:  上帝类    它是所有类的超类    它的方法所有的类都可以访问。不需要写extends,它是默认的
 *  
 * 
 * 类与类之间是单继承，但是可以多层继承
 */
class    Ye10{
     
}
class    Fu10  extends   Ye10{
       
}
class    Zi10   extends    Fu10{
       
}
public class Demo10Object {
       public static void main(String[] args) {
               Fu10      fu10=new    Fu10();
               Object   object=new  Object();
               /*
                * equals：是比较两个对象是否相等
                */
               boolean      st=object.equals(fu10);
               System.out.println("object比较object是否相等："+st);
               
               /*
                * getClass()：返回此 Object的运行时类。
                */
               Class    class1=object.getClass();
               System.out.println("class1="+class1);
               
               /*
                * 返回对象的哈希码值。就是返回一个整数值，相同的对象返回的值相同，
                * 不同的对象返回的哈希码值不一样。
                */
               int    a=object.hashCode();
               
               /*
                * toString()：返回对象的字符串表现形式。对象变成字符串。
                */
               String    stt=object.toString();
               /*
                * object=java.lang.Object@659e0bfd
                     stt=java.lang.Object@659e0bfd

                */
               
               System.out.println("object="+object);
               System.out.println("stt="+stt);
               
               //多态：  父类引用指向子类对象
               // 父类        对象名=new    子类();
               Object       fu11=new    Fu10();
               
               int[]       it=new   int[5];
               Object         in=it;
               
               
//               int   a=10;
//               String  string="10";
    }
}

潭州Java中级班（day_12）Super关键字，final关键字，抽象类，接口，Object类

猜你喜欢