Java类,对象,接口

   Java基础知识的类，对象，抽象类，接口的一个详细说明  

    类：主观抽象，是具有共同特性的对象的抽象，是对象的模板，可以实例化对象 
          定义格式： 
            package basic.com.base;//包名

               import java.util.Date;//引入依赖包

                 public class Play {  

                       int a =0; //属性

                      Date data = null;//属性

                     //默认构造器

                     public Play(){}

                     //带参数构造器

                      public Play(String name){...}

                    //方法

                      public void method1(){...}

 

                 }
        定义属性：实例变量 
            格式：[ 修饰符 ]  类型 变量名  [ = ? ] 
            实例变量定义在类中,在方法体之外，受访问控制符限制。 
            实例变量有默认值：各种各样的初始值，基本数据类型初始为基本的数据类型的默认值，对象类型的默认为null。
            在如果有重名作用域，实例变量和局部变量出现有命名冲突， 采用“局部优先”原则。         
        定义方法： 
            格式： [ 修饰符 ]  返回类型 方法名( 参数列表 ) [ throws  异常 ] { ······ }  
            java中所有参数都是值传递。 
            当没有值返回时，返回类型必须被定义为void。         
        构造器： 
            在创建对象的过程中调用的方法。 
            构造器没有返回类型。 
            构造器的名字与类名相同。 
            格式为：[ 修饰符 ]  类名( 参数列表 ){  }，修饰符可以是private、 protected、 default,public

            构造函数是提供对象创建，如果定义访问权限很小的构造函数，要考虑期初始的场景。
            在一个对象的生成周期中构造器只用一次，当类没有提供一个构造器，系统会自动提供一个无参的构造器。 
            获得对象的方式： 
                通过new（在堆空间中申请分配空间），new 类名()，可以通过这种形式创建一个对象，

                 这时的对象是无法使用，必须把他的地址存放进一个对象变量才能够使用。 
                例如 ： 
                    Person c=new Person(); 
            建议：定义一个类的时候，保留一个无参的构造器       
                         
        另外在类中注意一个this关键字： 
         1.在方法体重，this是个隐式参数，代表当前对象; 
           publie class Person{ 
                private String name; 
                public void setName(String name){ 
                     this.name=name;        //this.name为了区分两个name,为当前对象的成员变量 
                  } 
             } 
          2.在构造函数中使用this

              public class Play {

                  //带参数构造器

                  public Play(String name){

                       System.out.println("name===" + name);   

                   }   

                   public Play(String name,int age){

                          this(name); //this 代表这个类的构造方法，这个this(...)必须放在改构造器第一行

                          System.out.println("2=====");

                   }   

                  public static void main(String[] args) {

                         Play play = new Play("ddd",30);

                   }

 

               }
     注意： this不能出现在静态方法里面。          
 类、对象、实例三者的关系： 
     类：是对象的模板，可以实例化对象 
     对象：类的个体 
     实例：实现的对象 
     Person p;  //根据模板可以定义很多的对象，都有Person的属性，例如 Person  a,b,c;  
     p=new Person(); 
     其中 Person 为类，p为对象，new Person()为实例，p 赋值后也是实例了。 
 
方法重载（Overloading）： 
    方法重载是Java多态一个表现，多个同名函数同时存在，具有不同的参数个数/类型
    注意：如果参数类型和个数都一样，不能只以返回值的差异来实现重载，一定要参数个数或者类型不一样
方法的重写（Overriding）

     1>.父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的

     名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，

     而不需要重新编写相同的方法。

     2>.若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，

        则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字.
     3>.子类函数的访问修饰权限不能少于父类的,对于定义的异常，子类抛出的异常类一定是父类的异常类的子类。
封装： 
    类的属性加private修饰符，来限制只能够在类的内部进行访问，有效的保护数据。 
    对于类中的私有属性，要对其给出一对方法getXxx()，setXxx()访问私有属性，保证对私有属性的操作的安全性。 
    方法公开的是方法的声明，即只须知道参数和返回值就可以调用该方法，隐藏方法的实现的细节。 
    一个对象和外界的联系应当通过一个统一的接口，应当公开的公开，应当隐藏的隐藏。 
    放开读数据操作，限制写操作    
继承： 子类继承父类除private之外的属性和方法 
       一般就是把公用的属性，也就是共性形成一个父类，其他的个性的形成各自的子类 
    Java只支持单继承：一个类最多只有一个直接的父类。 
   1.方法覆盖： 
        方法名：相同 
        参数表：相同 
        访问限制符：相同或者更宽 
        返回值类型：相同或者子类返回的类型是父类返回的类型的子类（在JDK5.0以后） 
        抛出的异常：不能比父类更宽。    
     2.super关键字： 
        super()表示调用父类的构造器 
        super()也和this()一样必须放在方法的第一句 
        super()和this()不能同时出现          
        super可以屏蔽子类属性和父类属性重名时带来的属性遮盖，super. 表示调用父类的方法或属性 
        在子类的构造器中如果没有指定调用父类的哪一个构造器，那么就会调用父类的无参构造器，即super()       
    注意： 
        父类的构造器不能被子类继承 
        方法和属性可以被继承，权限不限制能否继承过来，子类的权限要大于父类的权限 
        先构造父类，后构造子类，先this后super          
多态： 
    多态是一种运行期的行为

    父类型的引用可以指向子类型的对象。

　　比如 Parent p = new Child();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；

　　如果有，再去调用子类的该同名方法。

    注意：静态static方法属于特殊情况，静态方法只能继承，不能重写Override，

     如果子类中定义了同名同形式的静态方法，它对父类方法只起到隐藏的作用。

      调用的时候用谁的引用，则调用谁的静态方法

      如果想要调用子类中有而父类中没有的方法，需要进行强制类型转换  

//编译错误
        //用父类引用调用父类不存在的方法
        //Animal a1 = new Cat();
        //a1.eat();
        
        //编译错误
        //向下类型转换时只能转向指向的对象类型        
        //Animal a2 = new Cat();
        //Cat c2 = (Dog)a2;

    多态的作用：把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，

                做出通用的编程，以适应需求的不断变化。 

 抽象类：abstract修饰类： 
        1.会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，

           也就是编译时类型 
        2.抽象类就相当于一个类的半成品，需要子类继承并覆盖其中的抽象方法，这时子类才又创建实例的能力，

           如果子类没有实现父类的抽象方法，那么子类也要为抽象类。 
        3.可以有自己的数据成员，也可以有非 abstract的成员方法

                抽象类

                public abstract class SuperTmp {

                       public void work(){

                          System.out.println("===work");

                        }   

                       public abstract void say();

 

                }

               实现类

               public class Sub extends SuperTmp{

                  @Override

                   public void say() {

                        System.out.println("====sub say==");   

                    }   

                  public void happy(){

                        System.out.println("===happy===");

                   }

                }

              在调用的时候注意

               SuperTmp tmp = new Sub();

               tmp.say();//只能调用抽象类的方法，不能调用实现类的方法，tmp.happy(),编译会报错

    abstract修饰方法： 
        1.实现部分以";"代替，需要子类继承实现。 
        2.抽象方法代表了某种标准，定义标准，定义功能，在子类中去实现功能（子类继承了父类并需要给出从

            父类继承的抽象方法的实现）。 
        3.方法一时间想不到怎么被实现，或有意要子类去实现而定义某种标准，这个方法可以被定义为抽象。 
    注意： 
        有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。

 

 接口：因为java不支持多重继承，所以有了接口，一个类只能继承一个父类，但可以实现多个接口，

       接口本身也可以继承多个接口。

       1.接口里面的成员变量默认都是public static final类型的。必须被显示的初始化，不能修改

       2.接口里面的方法默认都是public abstract类型的。。

       3.接口没有构造方法，不能被实例化。

       4.接口不能实现另一个接口，但可以继承多个接口。

       5.类如果实现了一个接口，那么必须实现接口里面的所有抽象方法，否则类要被定义为抽象类

       那么接口和抽象的汇总

          1 接口只能包含抽象方法，抽象类可以包含普通方法，或者private方法，接口不能定义private方法。 
          2 接口只能定义静态常量属性，抽象类既可以定义普通属性，也可以定义静态常量属性。 
          3 接口不包含构造方法，抽象类里可以包含构造方法。     

              抽象类不能被实例化，但不代表它不可以有构造函数，抽象类可以有构造函数，备继承类扩充