Java面向对象

一、基本概念

1.面向对象（Object Oriented）是一种新兴的程序设计方法，或者是一种新的程序设计规范(paradigm)，其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式

2.面向对象是一种符合人们思考习惯的思想，可以将复杂的事情简单化，将程序员从执行者转换成了指挥者

二、对象(Object)

• 1.对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。
• 2.类的实例化可生成对象，一个对象的生命周期包括三个阶段：生成、使用、消除。
• 3.当不存在对一个对象的引用时，该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。
• 4.过程和对象在我们的程序中是如何体现的呢？过程其实就是函数；对象是将函数等一些内容进行了封装。

三、类（class）

• 1.类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个主要部分
• 2.在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性和方法两个主要部分。
• 3.类可以看成是创建Java对象的模板
• 4.每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法
• 5.在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法

• 6.源文件声明规则

  1）一个源文件中只能有一个public类
  2）一个源文件可以有多个非public类
  3）源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java
  4）如果一个类定义在某个包中，那么package语句应该在源文件的首行
  5）如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面

• 7.在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类

• 8.内部类：
  1）成员内部类
  2）局部内部类
  3）匿名内部类

  （1）匿名内部类没有名字，因此只能使用一次，下次再使用重新创建对象
  （2）匿名内部类的适用情形：某个类不是经常使用，如只使用一次，使用完后不保存该实例的对象，为了便于代码的编写常采用匿名内部类
  （3）使用匿名内部类的前提条件：必须继承一个父类或实现一个接口
  （4）匿名内部类不能有构造方法。 （因为匿名内部类是没有类名的）
  （5）其他说明：
  无论是匿名内部类、接口或者抽象类，都不能实例化 但我们常用到的new 一个匿名内部类、接口或者抽象类实际上是执行3步的合并，即：
  a.先定义一个子类，让该子类继承上述接口或实现上述抽象类；
  b.然后new一个该子类的对象；
  c.将该子类的一个引用赋值给接口或者抽象类变量（它是依据java多态特性：父类指向子类的引用）。
  (6) interface Animal， Animal a = new Animal(){ 实现接口的方法 }
  匿名类其实就是相当于实现接口或者实现抽象类的一个具体类，以及不是抽象类或者接口，所以可以实例化，在匿名内部类中必须实现抽象方法，或者接口的方法，否则就会报错的，就是让匿名类变成可以实例化的类

  4）静态内部类

• 9.抽象类——不能实例化

  1）抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样
  2）由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
  3）如果你想设计这样一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法
  4）如果一个类包含抽象方法，那么该类必须是抽象类
  5）任何子类必须重写父类的所有抽象方法，或者声明自身为抽象类
  6）继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象
  7）抽象类不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象
  8）抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
  9）抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能
  10）构造方法，类方法（用static修饰的方法）不能声明为抽象方法
  11）抽象类可以有非抽象方法，也可以没有抽象方法

四、继承（extends,implements(接口多继承)）

1.子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。

2.Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承。

3.继承实现了代码的复用

4.Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的

5.子类不能继承父类中访问权限为private的成员变量和方法

6.类可以重写父类的方法，即命名与父类同名的成员变量。

7.子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

8.Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。super 的使用有三种情况：

访问父类被隐藏的成员变量，如：super.variable;
调用父类中被重写的方法，如：super.Method([paramlist]),super()调用父类构造方法;
调用父类的构造函数，如：super([paramlist]);

9.使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

10.super和this：

1）super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
2）this关键字：指向自己的引用。

11.子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。

12.如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。

五、多态——多态是同一个行为具有多个不同表现形式或形态的能力

1.对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为

2. 这使得同一个属性或方法在父类及其各个子类中具有不同的语义。例如：”几何图形”的”绘图”方法，”椭圆”和”多边形”都是”几何图”的子类，其”绘图”方法功能不同。

3. 当使用多态方式调用方法（Parent p = new Child();）时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法

4. Java的多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。

• 
  
• 1）编译（声明的对象类型）时多态：是指参数列表的不同, 来区分不同的函数, 在编译后, 就自动变成两个不同的函数名
• 2）运行（具体执行的对象类型）时多态：也就是动态绑定,是指在执行期间(而非编译期间)判断所引用对象的实际类型,根据实际类型判断并调用相应的属性和方法
• 3) 例子(虚拟方法调用)： Animal a = new Cat() a.eat() ; 都有方法eat();
  

（1） 当调用a.eat()时，编译器在编译时会在Animal 类中找到 eat()，执行过程 JVM 就调用 Cat 类的 eat()
（2） 因为a是 Animal 的引用，所以调用 e 的 eat() 方法时，编译器会去 Animal 类查找 eat() 方法
（3）在编译的时候，编译器使用 Animal 类中的 eat() 方法验证该语句,但是在运行的时候，Java虚拟机(JVM)调用的是 Cat类中的 eat()方法

六、封装

1.装性就是尽可能的隐藏对象内部细节，对外形成一道边界，只保留有限的接口和方法与外界进行交互。

2.封装的原则是使对象以外的部分不能随意的访问和操作对象的内部属性，从而避免了外界对对象内部属性的破坏。

3.可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。

4.要访问该类的代码和数据，必须通过严格的接口控制。

七、接口（interface）

1.一个类通过继承接口的方式，从而来继承接口的抽象方法

2.接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。

3.类描述对象的属性和方法。接口则包含类要实现的方法。

4.除非实现接口的类是抽象类，否则该类要定义接口中的所有方法

5.接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类

6.在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

7.接口中的方法都是公有的

8.接口特性：

1）接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
2）接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误
3）接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法

9.抽象类和接口的区别：

1）抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行
2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的
3）接口中不能有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法
4）一个类只能继承一个抽象类，而一个类却可以实现多个接口

10.接口与类的区别：

1）接口不能用于实例化对象
2）接口没有构造方法
3）接口中所有的方法必须是抽象方法
4）接口不能包含成员变量，除了 static 和 final 变量
5）接口不是被类继承了，而是要被类实现
6）接口支持多重继承

11.重写接口中声明的方法时，需要注意：

1）类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常
2）类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型
3）如果实现接口的类是抽象类，那么就没必要实现该接口的方法

12.

1) 若一个普通类实现了接口，那么，该普通类必须实现接口中所有的抽象方法。
2) 若一个抽象类实现了接口，那么，该抽象类可以实现接口中的抽象方法，也可以不实现。
3) 若一个普通的子类继承了抽象父类，该抽象的父类又实现了接口，那么，该普通的子类必须得重写，抽象父类中所有的抽象方法，并且，还必须得实现抽象的父类尚未实现的抽象方法

八、包

1.为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间

2.功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用

3.如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的

4.同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。

5.包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

6.类放在包中会有两种主要的结果

1)包名成为类名的一部分，正如我们前面讨论的一样
2)包名必须与相应的字节码所在的目录结构相吻合

7.一个公司使用它互联网域名的颠倒形式来作为它的包名.例如：互联网域名是 runoob.com，所有的包名都以 com.runoob 开头。包名中的每一个部分对应一个子目录。

---

注：文章是经过参考其他的文章然后自己整理出来的，有可能是小部分参考，也有可能是大部分参考，但绝对不是直接转载，觉得侵权了我会删，我只是把这个用于自己的笔记，顺便整理下知识的同时，能帮到一部分人。
ps : 有错误的还望各位大佬指正,小弟不胜感激