面向对象的三大特性

 

封装：
     类中如何定义成员变量？
      private   int  num;
     概念
     语法
       3步骤
   继承：减少冗余代码
      继承:一个类（子类）继承另一个类（父类）
     概念
     语法
       extends
      重载？？
      final(修饰符)
      static（main方法，static）      
   多态：
       一种事物的多种表现形式
      概念
      语法
        Father fa=new Son();//实例化
        //Son  son=new Son();
    接口：代表能力，一种约定。
       implement interface
    Java语言就是使用面向对象开发出来的。 
      Date      时间
      Calendar  日历
      Math
      包装类  Integer Double  Short  Float Boolean
    集合（不同结构不同使用）
    异常 （Exception）
    文件！IO流
    内存(基本数据类型的变量中，引用数据类型的变量中应用)
     int num=9;
     String str="admin";
     Student stu=new Student();
     int[] nums={};
     Student[] stus=new Student[10];
          写入
    内存---------》文件
        《--------
           读取
3.封装
     隐藏成员变量
   1.隐藏成员变量
      将成员变量前加入修饰符private 
      结果：其他类在创建狗的对象的时候，在调用成员变量时显示错误。
         The field Dog.name is not visible
    2.创建公有的getter/setter方法
      在此类中创建公有方法
         创建成员变量的赋值方法
           public  void setName(String name1){
           }
           注意：1.方法名称必须是set+成员变量第一个单词首字母大写的成员变量名称
                 2.方法的参数必须是成员变量的类型
         成员变量的取值方法
            public  String getName(){
               return name;//返回成员变量值 
            }
           注意：1.方法名称必须是get+成员变量第一个单词首字母大写的成员变量名称
                 2.方法的返回值必须是成员变量的类型（返回的是成员变量里面的值）
      3.在setter/getter方法中给加入属性控制 
  4.setter方法的参数名称和成员变量名称保持一致。（防止乱起名字）
        this.name=name;
  5.在本类中调用自己的成员变量和成员方法的时候，使用this
      this代表当前对象 
  6.特殊方法的第一种。
  
   构造方法：实例化--》创建对象+对象赋成员变量值
  
    Constructor
  
  
    语法
      publlic  类名(){
      
      }
      public Dog(){
      
      }
  
      
     1,创建类的时候都会有一个隐藏的无参构造方法。
     2,创建对象的时候就会调相应的构造方法。
     3,构造方法由于方法名称相同，因此构造方法的参数定义时注意，
       不要两个构造方法的传递参数一致（顺序  类型  个数）。
     4,当你在类中定义有参构造方法，隐藏的无参构造方法失效。
       因此必须在类中显示定义构造方法
       

     实例化两种方法
     
     第一种
       Dog dog=new Dog();
       
         dog.setName("");
         dog.setHealth();
         dog.setStrain("");
     第二种
       Dog dog=new Dog("",,"");

1.继承初始化顺序？
2.方法的重载和重写？
3.abstract final关键字

1.继承概念
   
   super    代表父类
   this     代表本类
   子类  extends  父类
2.继承关系初始化顺序。
   父类属性--》父类的构造方法--》子类属性--》子类的构造方法
   先父后子
   先属后构

3.方法的重载和重写？overloading和override区别
  重载 overloading
     规则：同一个类中
           方法名称相同
           参数列表必须不相同(类型 个数 顺序)
           返回值类型和访问修饰符无关
    构造方法重载
       public Student(){}
       public Student(String name){}
       public Student(String sex){}//错误
       public Student(String name,int age){}
    //方法名称具体意义
  重写 override
    规则：在继承关系中体现
           方法名字相同
           参数列表必须相同
           返回值的类型相同或者是其子类
           访问修饰符不能严于父类（父类是protected 子类是protected public ）
    方法重写：相对于继承而言，子类中对父类已经存在的方法进行区别修改。

4.abstract   抽象类

    1.修饰class后变为抽象类，限制实例化
    2.Pet类定义方法没有意义
       因此我们可以在Pet类中定义方法为抽象方法，
       抽象方法没有方法体。
  
  1）修饰类   限制实例化
  2）修饰方法   限制方法的实现，没有方法体
    
    抽象方法的实现步骤
       1.在父类的方法前添加abstract，去除方法体
       2.在子类中重写此抽象方法
       
    为什么使用抽象方法？
     1.父类只是知道子类应该有哪些方法，但是无法准确完成方法具体实现
     2.避免子类设计的随意性
    总结
       1.父类中编写抽象方法，子类必须重写
       2.抽象类中可以有普通方法，也可以有抽象方法
       3.抽象方法必须在抽象类中
       
5.final关键字

   修饰类
      此类就不能被继承
   修饰方法
      此方法不能被重写
      注意：final和abstract是两个相反的单词，绝对不能同时修饰
   修饰变量   
     常量：所有单词字母全部大写
        USER_NAME     AMDIN_NAME
        final String ORACLE_PASSWORD="123456";
     int num=9;
     num：变量
     9:常量
     
     永远都不会被改变的
     成员变量
        修饰成员变量必须声明的时候就赋值或者在构造方法中初始化
6.Object 上帝类 祖宗类

   Object类是所有类的父类。
   如果一个类没有使用extends关键字标识继承另一个类，那么这个类默认继承Object   
       
    因此自定义的类和底层开发人员的类

         String str="";
         str.equals("");//equals标明并不是在Object类，是String类。因为String子类重写了Object父类里的方法

   Object类中的主要方法。
    
     1.equals ：比较对象的引用是否指向同一块内存地址。（引用：指向一块内存地址）
       作业：想使用equals判断两个对象的属性是否相同。--》重写equlas
     2.toString()
         StringBuffer--》toString()--->StringBuffer转换为String类型
         
         返回的是哈希码值(对象地址字符串)。（Hash）

      我们直接使用System.out.println(dog);输出一个对象
      结果就是对象的地址字符串也叫哈希码值（com.sisp.oop4.object.Dog@659e0bfd）

      
      哈希码值：通过哈希算法(Hash)生成的一个字符串，用来区分我们的对象地址码。
  
    
   
        变量名        哈希码值

     子类可以重写toString

      3.getClass()  可以得到此对象的类型
       System.out.println(dog.getClass());
        //class com.sisp.oop4.object.Dog

 多态
     
   生活中的多态
      同一种事物，由于条件不同，则产生不同的结果
         事物的多种表现形态
    程序中多态
      同一个引用类型，使用不同的实例，执行不同的操作
        
        父类的引用  子类的实现
        //使用多态进行实例化
        Pet pet=new Dog();
        Pet pet=new Penguin();
        Pet pet=new Cat();
2.多态发生在继承关系中
3.多态实现的前提
    
      1.类与类之间存在继承关系
      2.类与接口之间存在实现关系（之后章节）
4.多态实现的步骤

    1.编写父类
    2.编写子类，一定要有子类重写父类的方法
    3.使用时，就可以使用父类的引用类型，子类的实例！！
      //使用多态进行实例化
        Pet pet=new Dog();
        Pet pet=new Penguin();
        Pet pet=new Cat();
5.多态实现的方式
   1.Pet pet=new Dog();
   2.使用父类作为方法的形参实现多态，
      调用具体方法传入实参作为子类的实例
   3.使用父类作为方法的返回值实现多态，
     定义方法的返回值为父类，调用方法的返回值为子类的实例
6.优点：程序的可扩展性
  缺点：使用多态进行实例化，实例化的对象只能调用子类重写父类的方法，
        子类特有的方法我们无法调用
        
        如何解决弊端？
        
           1.向上类型（自动类型转换）
             
             Pet pet=new Dog();
           
             好处：隐藏子类型，提供代码的可扩展型
             弊端：只能调用子类重写父类的方法，子类特有的方法我们无法调用
           2.向下类型（强制类型转换）
              int b=(int)9.8;
           
               Pet pet=new Dog();
                 pet.eat();
                 
               Dog dog=(Dog)pet;
  
                 dog.catchFlyDisc();

             好处：能调用子类特有方法
             弊端：向下类型有风险
                    容易发生异常
                    java.lang.ClassCastException（类型转换异常）
                    
              使用前进行判断，判断一个对象是否匹配另一个对象类型
                
                  对象 instanceof  类型（类名）