面向对象

1.面向过程 & 面向对象

面向过程思想：步骤清晰简单、第一步做什么、第二步做什么 ??面向过程适合处理一些较为简单的问题

面向对象思想物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。

什么是面向对象？ ??

面向对象编程（OOP） ??

面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据；

三大特性：1.封装 2.继承 3.多态

??从认识论角度考虑是先有对象后有类。对象，是具体的事物。类是抽象的，是对对象的抽象 ??从代码运行角度考虑是先有类后有对象。类是对象的模板。

2.构造方法

??使用new 关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

构造器的特点 1.必须和类的名字相同 ?2.必须没有返回值类型的声明，也不能写void ?3.一旦定义了有参构造，无参构造必须显示定义

构造器作用： 1.使用new 关键字必须要有构造器 ?2.用来初始化值

3.封装

该露的露，该藏的藏 ?程序设计要追求“高内聚、低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

4.继承

??继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。 extends 的意思是扩展，子类是父类的扩展。 Java中类只有单继承，没有多继承！（一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子）

??在Java中，所有的类都默认继承Object类，都默认直接或者间接继承Object类

super注意点： 1.super调用父类的构造方法，必须在构造方法中的第一行 ?

2.super 必须只能出现在子类的方法或者构造方法中！ ??

3.super 和 this 不能同时调用构造方法

super Vs this

代表的对象不同： this：本身调用者这个对象 ??

super：代表父类对象的应用

前提 this：没有继承也可以使用 ??

super：只能在继承条件才可以使用

构造方法： ??

this(); 本类的构造 ?

super(); 父类的构造！

5.重写

需要有继承关系，子类重写父类的方法！子类的方法必须和父类必要一致，方法体不同

前提

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大，单不能缩小： private（小） -》 public（大）
抛出的异常：范围可以被缩小，但不能扩大： ClassNofoundException（小） --》 Exception（大）

静态方法和非静态方法区别很大！静态方法调用跟左边有关

6.多态

??super(); 即同一方法可以根据发送对象的不同而采用多种不同行为方式 ??super(); 一个对象的实际类型是固定的，可以指向的引用类型就不确定了

1 public static void main(String[] args) {
2     // 能调用的方法都是自己的和父类的
3     Student s1 = new Student();
4     //不能调用子类独有的方法
5     Person s2 = new Student();
6     Object s3 = new Student();
7 }

子类重写父类的方法，执行子类的方法。编译看左边，运行看右边。多态是方法的多态，属性没有多态性。

多态的条件

继承关系
父类引用指向子类对象
方法重写

ClassCaseException 类型转换异常

以下情况方法不能重写 ??static 方法：属于类，它不属于实例 ??final 常量：在常量池里面的 ??private ：父类私有的方法

7.static 详解

静态方法、静态属性。

??非静态方法可以调用静态方法，静态方法只能调用静态方法。

??静态随着类的加载而加载。

??静态代码块，随着类的加载而调用，永远只执行一次。

 1 static{
 2     
 3 }
 4 
 5 匿名代码块，在构造器之前调用。每次创建对象的时候都会执行
 6 {
 7     
 8 }
 9

8.抽象类

??abstract 用来可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法。如果修饰类，那么该类就是抽象类。

??抽象类中可以没有抽象方法，但是有抽象方法的类必须声明为抽象类。

??抽象类，不能使用new 关键字创建对象，它是用来让子类继承的。抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

??子类继承抽象类，必须实现所有的抽象方法，否则该子类也要声明为抽象类。

抽象类中可以写普通方法抽象方法必须在抽象类中

9.接口

普通类：只有具体实现抽象类：具体实现和规范（抽象方法）都有接口：只有规范！自己无法写方法~专业的约束！

??接口就是规范，定义的就是一组规则，体现了显示世界中“如果你是。。。就必须能。。。”的思想。

如果你是天使，则必须能飞
如果你是汽车，则必须能跑
如果你是好人，就必须干掉坏人
如果你是坏人，就必须欺负好人

作用： ??1.约束 ??2.定义一些方法，让不同的人实现 ??3.方法都是public abstract ??4.常量都是 public static final ??5.接口中没有构造方法（它都不是类） ??6.可以实现多个接口 ??7.必须重写接口中的方法

10.内部类

??内部类就是在一个类的内部定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对于B类来说就是外部类了。

内部类分类

成员内部类
静态内部类
局部内部类
匿名内部类

成员内部类

 1 public class Outer {
 2     private int id;
 3 
 4     public void out(){
 5         System.out.println("这是外部类方法");
 6     }
 7 
 8     class Inner{
 9 
10         public void in(){
11             System.out.println("这是内部类的方法");
12         }
13     }
14 
15 }
16 //测试
17 
18 public static void main(String[] args) {
19     Outer outer = new Outer();
20     outer.out();
21     Outer.Inner inner = new Outer().new Inner();
22     inner.in();
23 }

静态内部类

 1 */
 2 public class Outer {
 3     private int id;
 4 
 5     public void out() {
 6         System.out.println("这是外部类方法");
 7     }
 8 
 9      static class Inner {
10         public void in() {
11             System.out.println("这是内部类方法");
12         }
13 
14     }
15 
16 }
17 //测试
18 public static void main(String[] args) {
19 
20     Outer outer = new Outer();
21     outer.out();
22 
23     Outer.Inner inner = new Outer.Inner();
24     inner.in();
25 }
26

局部内部类

 1 public class Outer {
 2     private int id;
 3     public void method() {
 4 
 5         class Inner {
 6             public void in() {
 7                 System.out.println("这是局部内部类");
 8             }
 9         }
10         Inner inner = new Inner();
11         inner.in();
12 
13     }
14 }
15 //测试
16 public static void main(String[] args) {
17     Outer outer = new Outer();
18     outer.method();
19 }

Java系列