1：面向对象和面向过程的区别：

面向过程：

  优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

缺点：没有面向对象易维护、易复用、易扩展

面向对象：

  优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护

缺点：性能比面向过程低

面向对象的思维方法：（终极目标：减少重复代码）

1：首先确定谁来做，然后确定怎么做

2：首先考虑整体，然后考虑局部

3：首先考虑抽象，然后考虑具体

2：对java的了解：

Java分为三个体系：

JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）

JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)

JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。

Java语言的特点：1，简单易学；2，面向对象（封装，继承，多态）；3，平台无关性（Java虚拟机实现平台无关性）；4，可靠性；5，安全性；6，支持多线程（C++语言没有内置的多线程机制，因此必须调用操作系统的多线程功能来进行多线程程序设计，而Java语言却提供了多线程支持）；7，支持网络编程并且很方便（Java语言诞生本身就是为简化网络编程设计的，因此Java语言不仅支持网络编程而且很方便）；8，编译与解释并存

Java是解释执行?

    这个说法不太准确。我们开发的 Java的源代码，首先通过 Javac编译成为字节码（bytecode），然后，在运行时，通过 Java虚拟机（JVM）内嵌的解释器将字节码转换成为最终的机器码。但是常见的 JVM，比如我们大多数情况使用的 Oracle JDK提供的 Hospot JVM，都提供了 JIT（Just-In-Time）编译器，也就是通常所说的动态编译器，JIT能够在运行时将热点代码编译成机器码，这种情况下部分热点代码就属于编译执行，而不是解释执行了

3:三大基本特性

封装：

1.定义：隐藏对象的属性和实现细节，仅对外公开接口,控制在程序中属性的读和修改的访问级别。

2.封装的目的是：增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。使用封装有三大好处：

                1、良好的封装能够减少耦合。

                2、类内部的结构可以自由修改。

                3、可以对成员进行更精确的控制。

                4、隐藏信息，实现细节。

3.封装的基本要求是:把所有的属性私有化，对每个属性提供getter和setter方法，如果有一个带参的构造函数的话，那一定要写一个不带参的构造函数。在开发的时候经常要对已经编写的类进行测试，所以在有的时候还有重写toString方法，但这不是必须的。

4:权限:尽可能小，才能体现封装性，更好的开发

public:

default默认:包级别的访问，在同一包自由访问，不同包就无法访问

protected:拥有和default一样的功能，但是只能修饰成员函数和成员变量（不能修饰类），允许子类使用父类的protected的成员函数成员变量（不同包也可以访问）

private:只能在当前类（声明它的类）使用

继承：

1.目的：实现代码的复用。

2.介绍：当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出来放到一个类中作为父类，其它两个类继承这个父类。继承后子类自动拥有了父类的属性和方法，但特别注意的是，父类的私有属性和构造方法并不能被继承。另外子类可以写自己特有的属性和方法，目的是实现功能的扩展，子类也可以复写父类的方法即方法的重写。

 生成对象的方法： 构造函数

            类名 对象名=new 类名（）

编译器自动添加 无参构造函数，类名（）是构造函数且无参，调用构造函数用new，如果类中有构造函数，则不添加无参构造函数，（构造函数不能被继承），在子类的构造函数中，默认下会自动调用父类的无参构造函数super();

 this的用法：“this是指向对象本身的一个指针”

this（参数）调用本类的构造函数 super(参数)调用父类的构造函数

this.函数名（）调用本类的成员函数 super.函数名（）调用父类的成员函数

生成子类的过程：super和this调用父类函数，必须在第一句，子类可以继承父类的成员变量和方法，但是不能继承构造函数，可能会有重复给成员变量赋初始值的情况，所以java默认用super（）；调用父类无参构造函数，或者可以自己写构造函数

说明在什么情况下需要用到this：

        第一、通过this调用另一个构造方法，用发是this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。

        第二、函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this。

        第三、在函数中，需要引用该函所属类的当前对象时候，直接用this。

super和this的异同：

       1)this（参数）调用本类的构造函数 super(参数)调用父类的构造函数

        this.函数名（）调用本类的成员函数 super.函数名（）调用父类的成员函数

      2)this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）

      3）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。

　  4）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。

　5）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。

　6）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

例如：Dog dog=new Dog()

栈：对象名（对象的引用） 堆：对象本身

子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量。有时候我们需要这样的需求：我们需要将某些事物尽可能地对这个世界隐藏，但是仍然允许子类的成员来访问它们。这个时候就需要使用到protected。

多态：

1.概念：相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。

2. Java实现多态有三个必要条件：继承、重写、向上转型。

         继承：在多态中必须存在有继承关系的子类和父类。

         重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

         向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

      只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

3.多态的实现方式：

（1）基于继承实现的多态

      基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。

（2）基于接口实现的多态

      继承是通过重写父类的同一方法的几个不同子类来体现的，那么就可就是通过实现接口并覆盖接口中同一方法的几不同的类体现的。

      在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。

      继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

4.多态性主要表现在如下方面:

    (1)方法重载.通常指在同一个类中,相同的方法名对应着不同的方法实现,但是方法的参数不同.

    (2)成员覆盖.通常指在不同类(父类和子类)中,允许有相同的变量名,但是数据类型不同;也允许有相同的方法名，但是对应的方法实现不同.

    (3)对象的转型：面向对象多态性的体现

        Person p=new Student()是向上转型，子类的对象赋值给父类的引用P，学生是人的子类。等于：Student s=new Student()；  Person p=s

        一个引用能够调用哪些成员（函数和变量），取决于引用的类型，P引用的只能是类Person的成员变量

        一个引用调用的方法取决于所指向的对象，P调用的方法取决于指向的Student的类对象，调用的是Student的方法

                向下转型：

                        Person p=new Student()；

                        Student s=(Student)p ；

                错误的向下转型：p是个人,但并不是拿到一个人，他就一定是学生

                        Person p=new Person()；

                        Student s=(Student)p；

5.多态的好处：程序的可扩展性及可维护性增强。

抽象：

1.介绍：在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、 设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象，我们不能把它们实例化（拿不出一个具体的东西）所以称之为抽象。

　　比如：我们要描述“水果”，它就是一个抽象，它有质量、体积等一些共性（水果有质量），但又缺乏特性（苹果、橘子都是水果，它们有自己的特性），我们拿不出唯一一种能代表水果的东西（因为苹果、橘子都不能代表水果），可用抽象类来描述它，所以抽象类是不能够实例化的。当我们用某个类来具体描述“苹果”时，这个类就可以继承描述“水果”的抽象类，我们都知道“苹果”是一种“水果”。

2.抽象方法：被abstract修饰的方法是抽象方法，抽象方法没有方法体。修饰符 abstract 返回值类型 函数名();抽象方法的修饰符只能用public或者protected或者没有修饰，不能被final，static，private修饰。

（1）、类即使不包含抽象方法，也可以定义成抽象类。

（2）、类中含有抽象方法的类一定要定义成抽象类。

（3）、抽象类中字段的定义和子类的访问与一般类没有变化。

（4）、扩展抽象类有两种方法，第一种是在子类中定义部分抽象方法或者抽象方法不定义，这样子类也必须定义成抽象类，第二种是定义全部的抽象方法，这样子类就可以不定义成抽象的了。

（5）、抽象类不能被实例化，但是可以定义一个抽象类的对象变量，这个变量可以引用非抽象子类的对象。

（6）、抽象类中包含有构造方法，也可以显式书写构造方法，构造方法在实例化子类的对象中调用。

4:接口与抽象类的区别:

不同点：

1、接口可以多实现，而抽象类只能单继承

2、抽象类可以有非抽象的方法和构造方法、变量，但是接口只能有抽象方法，静态常量。

3、抽象类和子类具有父子关系，子类能拥有父类中一些属性。接口虽然某个类实现一个接口，但是由于接口中的变量都为静态常量，不存在继承关系。

相同点：

1、无论接口还是抽象类，都无法直接实例化，其自身实例化需要靠实现类或子类来实现。

2、接口和抽象类都必须实现其中的所有方法。

抽象类（abstract class）的定义方式如下： 

public abstract class AbstractClass             //里面至少有一个抽象方法

{

 　　public int t;  //普通数据成员

　　 public abstract void method1();   //抽象方法，抽象类的子类在类中必须实现抽象类中的抽象方法

 　　public abstract void method2(); 

 　　public void method3();   //非抽象方法

 　　public int method4();

 　　publi int method4 (){

      　　…… //抽象类中可以赋予非抽象方法方法的默认行为，即方法的具体实现

 　　}

       public void method3(){

      　　…… //抽象类中可以赋予非抽象方法方法的默认行为，即方法的具体实现

 　　} 

}

接口（interface）的定义方式如下： 

public interface Interface

{ 

 　　static final int i;  //接口中不能有普通数据成员，只能够有静态的不能被修改的数据成员,static表示全局，final表示不可修改，可以不用static final 修饰，会隐式的声明为static和final

　　 public void method1();  //接口中的方法一定是抽象方法，所以不用abstract修饰

 　　public void method2();  //接口中不能赋予方法的默认行为，即不能有方法的具体实现

}

1、一个接口可以被多个类实现，一个类也可以实现多个接口。

2、接口中所有的定义的字段默认都是public static final 的属性，写和不写没有区别。

3、接口中的方法都是抽象的方法，并且抽象的方法默认都是public abstract修饰的，不能用其他的修饰符修饰，可以不写。

4、接口中没有构造方法

5、接口不是类，尤其不能使用new运算符实例化一个接口。但是可以声明接口的变量，这个变量可以指向实现了此接口的子类。

简言之抽象类是一种功能不全的类，接口只是一个抽象方法声明和静态不能被修改的数据的集合，两者都不能被实例化。

　　从某种意义上说，接口是一种特殊形式的抽象类，在ｊａｖａ语言中抽象类表示的是一种继承关系，一个类只能继承继承一个抽象类，而一个类却可以实现多个接口。在许多情况下，接口确实可以代替抽象类，如果你不需要刻意表达属性上的继承的话。

5：七大基本设计原则

一、单一职责原则(Single-Responsibility Principle):

单一职责的含义是：类的职责单一，引起类变化的原因单一。解释一下，这也是灵活的前提，如果我们把类拆分成最小的职能单位，那组合与复用就简单的多了，如果一个类做的事情太多，在组合的时候，必然会产生不必要的方法出现，这实际上是一种污染。所谓职责，我们可以理解他为功能，就是设计的这个类功能应该只有一个，而不是两个或更多。也可以理解为引用变化的原因，当你发现有两个不同的变化会要求我们修改这个类，那么你就要考虑撤分这个类了。SRP优点：消除耦合，减小因需求变化引起代码僵化。

二、开闭原则(Open-Close Principal):

开闭原则的含义是：对扩展开放，对修改关闭。就是，我们写完的代码，不能因为需求变化就修改。我们可以通过新增代码的方式来解决变化的需求。当然，这是一种理想的状态，在现实中，我们要尽量的缩小这种修改。 再解释一下这条原则的意义所在，我们采用逆向思维方式来想。如果每次需求变动都去修改原有的代码，那原有的代码就存在被修改错误的风险，当然这其中存在有意和无意的修改，都会导致原有正常运行的功能失效的风险，这样很有可能会展开可怕的蝴蝶效应，使维护工作剧增。

三、里氏替换原则(Liskov-Substituion Principle)：

里氏替换原则的含义是：子类可以在任何地方替换它的父类。也就是说在程序中将基类替换为子类，程序的行为不会发生任何变化。 Liskov替换原则是关于继承机制的设计原则，违反了Liskov替换原则就必然导致违反开放封闭原则。 Liskov替换原则能够保证系统具有良好的拓展性，同时实现基于多态的抽象机制，能够减少代码冗余，避免运行期的类型判别。

四、依赖倒置原则（Dependecy-Inversion Principle）：

面相对象的初期的程序，被调用者依赖于调用者。也就是调用者决定被调用者有什么方法，有什么样的实现方式，这种结构在需求变更的时候，会付出很大的代价，甚至推翻重写。 依赖倒置原则就是要求调用者和被调用者都依赖抽象，这样两者没有直接的关联和接触，在变动的时候，一方的变动不会影响另一方的变动,面向抽象编程，解耦调用和被调用者。 具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。 我们知道，依赖一定会存在于类与类、模块与模块之间。当两个模块之间存在紧密的耦合关系时，最好的方法就是分离接口和实现：在依赖之间定义一个抽象的接口使得高层模块调用接口，而底层模块实现接口的定义，以此来有效控制耦合关系，达到依赖于抽象的设计目标。 依赖于抽象是一个通用的原则，而某些时候依赖于细节则是在所难免的，必须权衡在抽象和具体之间的取舍，方法不是一成不变的。依赖于抽象，就是对接口编程，不要对实现编程。

五、接口隔离原则(Interface-Segregation Principle):

它的含义是尽量使用职能单一的接口，而不使用职能复杂、全面的接口。很好理解，接口是为了让子类实现的，如果子类想达到职能单一，那么接口也必须满足职能单一。 相反，如果接口融合了多个不相关的方法，那它的子类就被迫要实现所有方法，尽管有些方法是根本用不到的。这就是接口污染。

六、迪米特法则：

又叫作最少知道原则，迪米特原则要求尽量的封装，尽量的独立，尽量的使用低级别的访问修饰符。就是说一个对象应当对其他对象有尽可能少的了解,不和陌生人说话。这是封装特性的典型体现。 一个类如果暴露太多私用的方法和字段，会让调用者很茫然。并且会给类造成不必要的判断代码。所以，我们使用尽量低的访问修饰符，让外界不知道我们的内部。这也是面向对象的基本思路。这是迪米特原则的一个特性，无法了解类更多的私有信息。 迪米特原则要求类之间的直接联系尽量的少，两个类的访问，通过第三个中介类来实现。

七、组合/聚合复用原则：

组合/聚合复用原则的含义是，如果只是达到代码复用的目的，尽量使用组合与聚合，而不是继承。因为继承的耦合性更大，组合聚合只是引用其他的类的方法，而不会受引用的类的继承而改变血统。说白了就是我只用你的方法，但我们并不是同类