面向对象内容学习整合

面向对象

• 物以类聚，分类的思维方式，思考问题首先解决问题需要哪些分类，然后对分类进行单独思考，再对分类细节进行面向过程的思索
• 面向对象适合处理浮渣的问题，适合处理多人协作问题

从宏观上把握、从整体上合理分析，我们使用面向对象的思路分析系统，具体到围观操作，仍需要面向过程的思路去处理

OOP思想，本质是：以类的方式组织代码，以对象的形式组织封装数据

使用new关键字创建对象，除了分配内存空间，还有进行默认的初始化以外还会调用构造器方法。

构造方法特点

• 必须和类名相同
• 不能有返回值

作用

• new 本质在调用构造方法
• 初始化对象的值

定义有参构造后，必须显式定义无参构造。

类与对象

1. 类是一个模板：抽象，对象是一个具体的实例

2. 对象的引用：除八个基本类型之外，都是引用类型，对象是通过引用操作的：栈---->堆

3. 默认初始化：

• 数字：0 0.0
• char:u0000
• boolean:false
• 引用类型：null

4. 对象的创建和使用

• 必须使用new关键字创造对象
• 对象的属性
• 对象的方法

5. 类：

   • 静态的属性 属性
   • 动态的行为 方法

   方法的重载：相同方法，不同参数

面向对象三大特性

• 封装：属性私有，get/set方法

  • 提高程序的安全性，保护数据
  • 隐藏代码的实现细节
  • 统一接口
  • 提高了系统的可维护性

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

• 继承：extends

  继承的本质是对某一类的抽象，super获取父类的内容

  方法的重写

  重写都是方法的重写，非静态方法才会重写，静态方法不能重写

  重载是指，方法名相同，参数列表不同或者返回值不同

  重写：需要有继承关系，子类重写父类的方法！

  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符：范围可以扩大，不能缩小
  4. 抛出的异常：范围可以被缩小，但不能扩大

  重写，子类的方法和父类必要一致；方法体不同！

  super注意点：

  • super调用父类的构造方法，必须在构造方法的第一个

  • super必须只能出现在子类的方法或者构造方法中

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

  • super VS this

    • 代表的对象不同：

      this:本身调用者这个对象

      super：代表父类对象的应用

    • 前提

      this:没有继承也能使用

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

    • 构造方法

      this()；本类的构造

      super();父类的构造

• 多态

  多态即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

  一个对象的实际类型是确定的，单可以指向对象的引用的类型有很多。

  多态是方法的多态，属性没有多态性

  无法重写的方法有

  1. static方法
  2. private方法
  3. final常量

  多态存在的条件

  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象
  1. 把子类转换成父类，向上转型；
  2. 把父类转换成子类，向下转型；强制转换
  3. 方便方法的调用，减少重复的代码！简洁

static关键字详解

静态变量，可以通过类调用

非静态方法可以调用静态方法，

静态方法不能调用非静态方法，因为静态方法与类一起生成，生成的时候普通方法还没加载，所以无法使用

静态代码块

static{
    //静态代码块，在类加载的时候执行，只执行一次，与类同时生成
}
{
    //匿名代码块，可以用于赋予初值
}
//运行顺序静态代码块>匿名代码块>构造方法

抽象类

abstract关键字

类只能单继承，接口可以多继承

抽象类里的抽象方法子类必须写出

public abstract void doSomething();//抽象方法，只有方法名字，没有方法的实现

抽象类通过抽象公用的方法，可以提高开发效率

1. 不能new抽象类，只能靠子类去实现他；约束

2. 抽象类中可以写普通方法

3. 抽象方法必须在抽象类中

   抽象的抽象：约束

抽象类是有构造方法的，只是不能创建实例对象，可以通过子类的super()调用抽象类的构造方法。

接口：关键字interface

接口就是规范，自己无法写方法,接口的本质是契约，制定好后大家都遵守

public interface Service{
    int AGE=99;//接口中的属性都常量，public static final
    //接口中的所有定义都是抽象的public abstract
    void run(String name);
}

接口是面向对象的精髓

作用：

1. 约束
2. 定义一些方法，让不同的人实现
3. 方法默认带有public abstract
4. 常量默认带有public static final
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口，必须要重写接口中的方法

内部类

• 成员内部类

public class Outer{
    private int id=10
    public class Inner{
        public void in(){
            xxx;//可以获得外部类的私有属性
        }
    }
}
Outer outer =new Outer();
Outer.Inner inner=outer.new Inner();

• 静态内部类

public class Outer{
    private int id=10
    public static class Inner{
        public void in(){
            xxx;
        }
    }
}

• 局部内部类

public class Outer{
    public void method(){
        class Inner{//局部内部类
            public void in(){}
        }
    }
}

• 匿名内部类

public class Outer{
   new UserService(){
       public void hello(){
           
       }
   }
}
interface UserService{
    void hello();
}