面向对象基础

（一）

类与对象的关系：

类用于描述多个对象的共同特征，它是对象的模板。

对象用于描述显示中的个体，它是类的实例。

类：{

成员变量：属性

成员方法：方法     ----->定义在方法中的变量--->局部变量

}

对象创建：

   
   

    
    

     
     Person p = new Person();
    
    
   
   

类的封装：

在定义一个类时，对成员变量的访问做一些限定，不允许外界随意访问。

---->将类中的属性私有化，用private修饰。为了能让外界访问到私有属性，需要提供public修饰的公有方法，其中也包括获取属性值的getXxx（）和设置属性值的setXxx（）。

构造方法：

特殊的成员。在类实例化对象时被自动调用。

满足条件：方法名要和类名相同。方法名前面没有返回值类型的声明。不能使用return语句返回一个值。

构造方法重载： 一个类中可以有多个构造方法，只要这些构造方法的参数类型或参数个数不同就可以。

在定义有参构造方法时，最好也要再定义一个 无参构造方法。

this关键字：

可以明确的去访问一个类中的成员变量，解决与局部变量的冲突问题。

   
   

    
    

     
     class Person{
    
    
    
    

     
       int age;
    
    
    
    

     
       public Person(int age){
    
    
    
    

     
       this.age = age;
    
    
    
    

     
       }
    
    
    
    

     
     }
    
    
   
   

通过this关键字调用成员方法：在一个方法中调用另外一个方法。

   
   

    
    

     
     class Person(){
    
    
    
    

     
       public void openMouth(){
    
    
    
    

     
         ....
    
    
    
    

     
       }
    
    
    
    

     
       public void speak(){
    
    
    
    

     
         this.openMouth(); //等同于直接写 openMouth();
    
    
    
    

     
       }
    
    
    
    

     
      
    
    
    
    

     
     }
    
    
   
   

可以在构造方法中使用this（）方法来调用其他的构造方法。且必须位于第一行，且只能出现一次。

垃圾回收：

当一个对象成为垃圾后，会暂时的保存在内存中，当垃圾堆积到一定的程度，java虚拟机会启动垃圾回收器将这些垃圾对象从内存中释放。

同时，也可以使用System.gc()；方法，来通知虚拟机来回收垃圾。当一个对象在内存中被回收释放之前，它的finalize()方法会被自动调用。

finalize()在什么时候被调用?
有三种情况
1.所有对象被Garbage Collection时自动调用,比如运行System.gc()的时候.
2.程序退出时为每个对象调用一次finalize方法。
3.显式的调用finalize方法

static关键字：

修饰成员变量（不能修饰局部变量），这个变量被称为静态变量，静态变量被所有的实例共享。

静态方法：在方法前面加上static，可以使用“类名.方法名”直接访问，不需要创建对象。而没有static修饰的方法需要创建实例才能访问。

类的继承：

extends关键字，子类继承父类的时候，会自动拥有父类所有的成员。

类只支持单继承（一个类只能有一个父类）。多层继承是可以的。

子类重写父类方法：重写的方法需要和父类被重写的方法有相同的方法名，参数列表和返回值。

***：子类重写父类方法时，不能使用比父类中被重写的方法更严格的访问权限。

super关键字：

调用父类的成员变量和成员方法。

   
   

    
    

     
     super.成员变量
    
    
    
    

     
     super.成员方法（参数一，参数二...）
    
    
   
   

使用super调用父类的构造方法。这行代码必须位于子类构造方法的第一行，并且只能出现一次。

   
   

    
    

     
     super（[参数一，参数二...]）
    
    
   
   

final关键字：

可修饰类，修饰变量，修饰方法。

final修饰的类不能被继承。

final修饰的方法不能被子类重写。

final修饰的变量是常量，只能赋值一次。

抽象类：

抽象方法：不包含方法体的方法，且用abstract关键字来修饰。

   
   

    
    

     
     abstract void shout();
    
    
   
   

当一个类中包含抽象方法，该类必须使用abstract关键字来修饰，使用abstract修饰的类称为抽象类。

   
   

    
    

     
     abstract class Animal{
    
    
    
    

     
       abstract int shout();
    
    
    
    

     
       }
    
    
   
   

**：抽象类时不能被实例化的。因为抽象类有可能包含抽象方法，抽象方法没有方法体，不可以被调用。

如果想调用抽象类中的方法，则可以创建一个子类来继承这个类，在子类中将抽象类中的抽象方法进行实现。

接口：

如果一个抽象类中的所有方法都是抽象的，则可以将这个类用另一种方式表示----->接口。

定义接口时，用interface关键字来声明。

   
   

    
    

     
     interface Animal{
    
    
    
    

     
       int ID = 1;
    
    
    
    

     
       void breathe();
    
    
    
    

     
       void run();
    
    
    
    

     
     }
    
    
   
   

接口中的方法没有用abstract来修饰，是因为接口中定义的方法和变量都包含一些默认的修饰符。

接口中的方法中使用的默认修饰符是------>"public abstract"，即抽象方法。

接口中的变量中使用的默认修饰符是------>"public static final"，即全局常量。

调用接口中的方法，需要定义一个类，使用implements关键字实现接口中的方法。一个类可实现多个接口。

一个接口也可以继承另外的一个接口。

同时有继承和实现时，要先继承，后实现。

多态：

在同一个方法中，由于参数类型不同而导致执行效果各异的现象就是多态。

java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象。根据被引用子类对象的特征不同，得到不同的结果。

   
   

    
    

     
     interface Animal{
    
    
    
    

     
        void shout(); 
    
    
    
    

     
     } 
    
    
    
    

     
     class Cat implements Animal{
    
    
    
    

     
        public void shout(){
    
    
    
    

     
         syso("miao~~~~");
    
    
    
    

     
        }
    
    
    
    

     
     class Dog implements Animal{
    
    
    
    

     
        public void shout(){
    
    
    
    

     
         syso("www~~~~");
    
    
    
    

     
        }
    
    
    
    

     
     }
    
    
    
    

     
      
    
    
    
    

     
     public class test{
    
    
    
    

     
        Animal a1 = new Cat();
    
    
    
    

     
        Animal a2 = new Dog();
    
    
    
    

     
        animalshout(a1);
    
    
    
    

     
        animalshout(a2);
    
    
    
    

     
     }
    
    
    
    

     
      
    
    
    
    

     
     public static void animalshout(Animal an){
    
    
    
    

     
        an.shout();
    
    
    
    

     
     }
    
    
   
   

对象的类型转换：

    
    

     
     

      
      public static void animalshout(Animal an){
     
     
     
     

      
          Cat cat = (Cat) animal;
     
     
     
     

      
          cat.shout();
     
     
     
     

      
          cat.sleep();
     
     
     
     

      
      }
     
     
    
    

为了引用cat类的方法，可以将animal转换成cat类型的。

为了判断一个对象是否为某个类（或接口）的实例或者是子类实例，可以用instanceof关键字。

   
   

    
    

     
     public static void animalshout(Animal an){
    
    
    
    

     
         if(animal instanceof Cat){   //判断animal是否是cat类型的实例对象
    
    
    
    

     
           Cat cat = (Cat) animal;
    
    
    
    

     
           cat.shout();
    
    
    
    

     
           cat.sleep();
    
    
    
    

     
         }else{
    
    
    
    

     
           syso("...");
    
    
    
    

     
         }
    
    
    
    

     
     }
    
    
   
   

Object类：

所有类都默认继承Object类。toString（）方法，返回的是一个哈希地址（内存地址）。

匿名内部类：

堆内存和栈内存：

栈内存：存放一般代码逻辑，简单变量，结构体。栈内存就是一个很长的栈，线性的，里面存放着各种逻辑，还有整型、浮点等数据，但是数据量过大时，会影响性能，因此会将大量的数据存放在堆内存中，之后，栈内放堆内存的地址。

堆内存：放置对象，被装箱的数据。

面向对象：

基本特征：封装，继承，多态。

五大基本原则：

单一职责原则（SRP）：一个类中应该仅有一个引起它变化的原因，来降低类的复杂度。

开放封闭原则（OCP）：既开放又封闭。对扩展是开放的，对更改是封闭的。

里氏替换原则（LSP）：子类可以替换父类，并且出现在父类能够出现的任何地方。因此父类应该尽可能的用接口或者抽象类来实现。体现了java的多态。

依赖倒置原则（DIP）：传统的结构化编程中，都是最上层模型依赖下面的子模型来实现，也称为高层依赖低层实现。因此，DIP原则就是要逆转这种依赖关系，让高层模块不要依赖底层模块，所以称为依赖倒置原则。

假设B是较A低的模块，但B需要使用到A的功能，这个时候，B不应当直接使用A中的具体类；而应当由B定义一抽象接口，并由A来实现这个抽象接口，B只使用这个抽象接口；这样就达到了依赖倒置的目的，B也解除了对A的依赖，反过来是A依赖于B定义的抽象接口。

依赖倒置原则可以减少类间的耦合性，提高系统的稳定性，减少并行开发引起的风险，提高代码的可读性和可维护性。

接口隔离原则（ISP）：意思是，使用多个专门的接口比使用单个接口要好得多。暴露行为让后面的实现类知道的越少越好。

---

Final、finally、finalize的区别：

Final是一个修饰字，如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明成abstract的，又被声明成final的。将变量和方法声明为final，可以保证他们在使用中不被修改。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法同样只能使用，不能重载。
    Finally在异常处理时提供finally块来执行任何清除操作。如果抛出一个异常，那么相匹配的catch子句就会执行，然后控制就会进入finally块。
    Finalize 方法名。Java技术允许使用finalize方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾回收器在确定这个对象没有被引用时对这个对象调用的。它是在Object类中定义的，因此所有的类都继承了它。子类覆盖finalize方法以整理系统资源或者执行其他清理工作。Finalize方法是在垃圾收集器删除对象之前对这个对象调用的。

（二）

单例模式：

只能有一个实例对象，因此构造方法必须要是私有的，并且要自己在类内部创建new一个对象，这个对象也要是私有的，静态的。还要有一个方法，让外部来访问此方法，才能进行创建此对象，这个方法需要时static的，并且返回一个变量（new 对象的变量）。

     
     

      
      

       
       class Single{
      
      
      
      

       
        
      
      
      
      

       
       private static Single INSTANCD = new Single();  //用private修饰，外界不能直接访问，用static，说明只能有一个
      
      
      
      

       
       private Singleton(){}       //构造方法使用private修饰，这样在类的外部就不能创建实例了
      
      
      
      

       
       public static Single getInstance(){    //为了外部能够引用这个方法来获得实例
      
      
      
      

       
           return INSTANCE;
      
      
      
      

       
           }
      
      
      
      

       
        
      
      
      
      

       
       }
      
      
     
     

类的访问权限修饰符：

	同一个类	同一个包	不同包的子类	不同包的非子类
Private	√
Default	√	√
Protected	√	√	√
Public	√	√	√	√