Java面向对象基础要点

/**
 ########################################################################################################
 
 面象对向编程（OOP）基本概念
 对象、类、实体间的关系
 先将物理存在的一个实体（如手表）抽象(定义)成概念世界的抽象数据类型（手表类），这个抽象数据类型里包括了数据和操作
 行为（即类中成员[类成员，实例成员]的成员变量和成员方法），再将这个抽象数据类型（手表类）具体化（new 关键字实例
 化）为现实世界中具体的一个具体物体的映射（即对象）
 --------------------------------------------------------------------------------------------------------
 对于类的成员来说，分为类成员（用关键字static修饰的成员）和实例成员（非static的成员[对象成员]）
 类中成员包括：成员变量和成员方法(成员变量：用来存储数据的变量；成员方法：用来处理问题的算法)
 
 ########################################################################################################
 
 面象对向编程(OOP)的特点:1.抽象、2.封装、3.继承、4.多态
 --------------------------------------------------------------------------------------------------------
 1.抽象
      a).过程抽象:用一种计算机语言表现出来的处理过程的步骤(如C语言的函数);
      b).数据抽象:用一种计算机语言表现出来的一个数据类型（如JAVA语言的类[包括数据和行为]）
   各自的优缺点
      a).过程抽象强调功能完成的过程和步骤，过程抽象利用控制、降低整个程序的复杂度。但程序自由度不大，难于规范化。
      操作起来有一定难度，质量上不易保证。
      b).数据抽象：一方面可以去掉与问题核心无关的细节，使开发者比较集中关键部分。另一方面，对数据和行为的分析和
      定义可以帮助开发者对整个问题更深入、准备认识。
   例：class Car{
        数据（成员变量）：名称、价格、颜色...
        行为（成员方法）：发动、驾驶...
       }
 --------------------------------------------------------------------------------------------------------
 2.封装
      封装是指将为右成员的数据和行为（成员变量和成员方法）组织在类里（通过访问修饰符来控制）。在JAVA中包也体现
      的封装的概念。
   例：public class Car{
        private String name;
        protected String color;
        ...
        Car(){}
        public void Start(){ //汽车的发动
        ...
        }
       }
 --------------------------------------------------------------------------------------------------------
 3.继承(JAVA只能是单一继承)
      继承父类的前提：该类必须为非final类;用final定义的类称为：最终类；用final定义的成员称为：最终成员;
                     用final定义的类或成员都不允许修改
      一个类用extends继承一个父类，这个类被称为子类;子类可以继承父类中非私有（private）(成员变量和成员方法)
      通过继承后，可以对父类的成员变量和成员方法进行多态效应（方法重载，方法覆盖(除final方法外)，成员变量的隐藏）
      。从而达到扩展子类和完善子类功能的目的。
   例：class SuperClass{
          final int a;  //在子类中不允许修改；最终属性
          ...
          SuuperClass(){
          a = 10;
          }
       }
      
       class SubClass extends SuperClass{ //用关键字extends继承父类SuperClass
        ...
       }
 --------------------------------------------------------------------------------------------------------
 4.多态 a).覆盖 b).隐藏 c).重载 
       覆盖
           是指子类对父类成员方法的重新定义(重写)
       隐藏
           是指子类对父类成员变量的重新定义(重写)
       重载
           是指同一类中方法名相同,但形式参数的个数不同或形式参数的类型不同,或形式参数的类型顺序不同
   覆盖、隐藏例：
     //以上两种情况用于继承
      class SuperClass{
        int n;
        SuperClass(){
         n = 10;
        }
        void print(){
        System.out.println("我是SuperClass的方法，功能是打印n值；n="+n);
        }
      }
     
      class SubClass extends SuperClass{
        int n = 20; //隐藏父类属性n
        public static void main(String[] args){
        SubClass sub = new SubClass();
        sub.print();
        }
        void print(){
        System.out.println("我是SubClass的方法，功能是打印n值；n="+n);
        }
      }
     
   重载:
   //重载用于同一个类中相同方法名的不同处理情况
    class SuperClass{
      public static void main(String[] args){
       SuperClass sup = new SuperClass();
       sup.print();
       sup.print("都市海");
       sup.print("hello","Justin");
       sup.print("test",5);
       sup.print(5,"test");
      }
     
      void print(){
      System.out.println("无参数的print()输出!");
      }
     
      void print(String name){
      System.out.println("name="+name);
      }
     
      void print(String log,String name){
      System.out.println(log+","+name+"!");
      }
     
      void print(String str,int n){
      System.out.println("我的方法参数格式是：print(String str,int n)");
      }
     
      void print(int n,String str){
      System.out.println("我的方法参数格式是：print(int n,String str)");
      }
    }
 -------------------------------------------------------------------------------------------------------
 
 ########################################################################################################
 **/
/*
class SuperClass {
 protected int n = 10;
 protected void print() {
     System.out.println("我是SuperClass中的print()");
 }
}

class SubClass extends SuperClass{
 int n = 20; //本类中的成员变量n=20隐藏了SuperClass中的成员变量n=10
 protected void print() {  //本类中的成员方法print()覆盖了父类(SuperClass)中的成员方法print()
     System.out.println("我是SubClass中的print()");
 }
 
 public static void main(String[] args){
  SubClass sub = new SubClass();
  System.out.println(sub.n); //调用的是本类的n值,因为本类中已经把父亲中的n隐藏了
  SuperClass sup = sub;  //向上造型,sup被赋值为:sub
  
  //总结:虽然说sub向上造型了sup,sup类型为:SubClass.但sup不能访问sub中的成员,还是只能访问sup的成员
  
  System.out.println(sup.equals(sub));
  System.out.println(sup.getClass());
  System.out.println(sup.n);//访问的是SuperClass中的成员变量n
  
  sub.print();  //SubClass类中的print()
  sup.print();  //访问的是SubClass类中的print()
  sub.modi();   //调用本类中的方法  
  
 }
 
 void modi(){
 super.print(); //这样访问父类(SuperClass)中的print()
 }
}
*/

/*
//覆盖、隐藏
class SuperClass{
    int n = 2;
    SuperClass(){
     n = 10;
    }
    void print(){
    System.out.println("我是SuperClass的方法，功能是打印n值；n="+n);
    }
  }
 
  class SubClass extends SuperClass{
    int n = 3; //隐藏父类属性n
    SubClass(){
    n = 20; 
    }
    public static void main(String[] args){
    SubClass sub = new SubClass();
    sub.print();   
    }
    void print(){ //覆盖父类print()   
    System.out.println("我是SubClass的方法，功能是打印n值；n="+n);
    }
  }
*/
//重载
class SuperClass{
    public static void main(String[] args){
     SuperClass sup = new SuperClass();
     sup.print();
     sup.print("都市海");
     sup.print("hello","Justin");
     sup.print("test",5);
     sup.print(5,"test");
    }
   
    void print(){
    System.out.println("无参数的print()输出!");
    }
   
    void print(String name){
    System.out.println("name="+name);
    }
   
    void print(String log,String name){
    System.out.println(log+","+name+"!");
    }
   
    void print(String str,int n){
    System.out.println("我的方法参数格式是：print(String str,int n)");
    }
   
    void print(int n,String str){
    System.out.println("我的方法参数格式是：print(int n,String str)");
    }
  }