面向对象总结

胡泽宇 2020年02月03日 231次浏览

总决:定义类、创建对象、调用方法

3种类型:

类、接口、枚举

5大成员(类的五大成员):

成员变量、方法、构造器、初始化块、内部类

4种修饰符:

private|protected|public|default(访问权限修饰符)、static、final、abstract

定义类:

[修饰符] class 类名 extends 父类 implement 接口1,接口2
{
   五大成员(成员变量、方法、构造器、初始化块、内部类)
}

成员变量的语法:

[修饰符] 类型 变量名 [= 初始值];

方法的语法:

[修饰符] 类型 方法名(形参列表)
{
   可执行的语句
   //如果声明了返回值类型,必须带有有效的return语句
}

构造器的语法:

[修饰符] 构造器名(形参列表)
{
   可执行的语句
}
//如果你没有写任何构造器,系统会为该类提供无参数的构造器。
//子类的构造器,一定会调用父类无参数的构造器。

初始化块的语法:

[static]{
   可执行的语句
}
  • 实例初始化块:假象,其实会被还原到每个构造器的所有代码之前。
    因此,每次调用构造器创建对象时,总会先执行实例初始化块,然后再执行构造器代码。
  • 类初始化块:第一次主动使用该类时,程序会为该类变量分配内存空间,并初始化该类。

接口的语法:

[修饰符] interface 接口名 extends 接口1,接口2{
   1.成员变量,总有 public static final ,总是常量
   2.方法(抽象方法,Java8有了类方法、default方法)
   3.内部类
}

使用类:

1.声明变量2.创建对象3.调用类方法或类对象4.派生子类

使用接口:

1.声明变量2.调用类方法或类对象3.定义实现类,实现接口中所有方法,否则该类也只能定义成抽象类

4个修饰符:

  • 访问权限修饰符(程度由小到大):
    1.private(类访问权限(只能在当前类里面访问))
    2.不写default(包访问权限)
    3.protected(子类访问权限)
    4.public
  • static
    有static的属于类,没有static 的属于实例。
    因此static只能修饰五大成员的其中4个(成员变量、方法、初始化块、内部类)除了构造器
    重要规则:静态成员不能访问非静态成员。
  • final
    • 修饰变量,表示该变量被赋值之后不能重新赋值。
      • final修饰的实例变量,必须显式指定初始值,且只能在3个位置指定初始值。
        三个位置:(定义的时候,实例初始化块,构造器)
      • final修饰的类变量,必须显示指定初始值,且只能在2个位置指定初始值。
        两个位置:(定义的时候,类初始化块)
      • final修饰局部变量,变化很小。与普通局部变量的区别是:不能被重新赋值。
      • final修饰宏替换的变量
    • final修饰方法:该方法不能被重写
    • final修饰类:该类不能被继承
  • abstract
    • 修饰类:抽象类,得到了拥有抽象方法的能力,失去了创建对象的能力。
      • 抽象类:体现了多个类的模板
    • 修饰方法:抽象方法。只有方法签名,没有方法体(方法后面花括号以及里面的内容)。

内部类:

放在其他类的类体中定义的类,该类就属于内部类,包含内部类就被称为外部类
内部类的文件名: 外部类$内部类.class

public final|abstract class A{
    [static] class B extends 父类 implements 多个接口{

    }
}
  • 什么时候用内部类(内部类存在的意义):
    • 当某个类的实例必须要依附于另外一个类的存在而存在,内部类可以提供更好的封装,因为可以完全private
  • 内部类与顶层类的语法区别:
    • 内部类可以多如下修饰符:static、private、protected
    • 非静态内部类不能拥有静态成员。除非是常量 public final static
      • 非静态内部类中添加静态成员报错:
        1
      • 除非是常量 public final static
        2
    • 内部类可以直接访问外部类的私有成员,但静态内部类不能访问外部类的非静态成员:
      3
      • 静态内部类不能访问外部类的非静态成员:
        4
  • 区分变量:
    • 内部类直接访问外部类的成员变量
    • 但如果内部类的方法、内部类的成员变量与外部类重名的话,就需要进行区分:
      外部类.this.实例成员
      • this.引用,限定访问当前类的实例变量
      • 外部类.this.引用,限定访问当前类的外部类的实例变量
        5

使用内部类:

  • 在外部类里面使用内部类:
    • 基本上使用内部类与使用其他类没什么区别
    • 注意: 静态成员不能使用非静态的内部类创建实例。
  • 在外部类外面使用静态内部类:
    该静态内部类一定不能用private修饰
    在外部类的外面使用静态内部类--只要把外部类当成静态内部类的包名即可。
    • 声明变量:
      外部类.静态内部类 变量名;
    • 创建对象:
      new 外部类.静态内部类的构造器(参数);
    • 调用类方法或访问类变量(静态变量):
      外部类.静态内部类.类变量;
      外部类.静态内部类.类方法(参数);
    • 派生子类:
      extends 外部类.静态内部类
    • 示例:
      • 先创建一个静态内部类:
        6
      • 声明静态内部类的变量、创建对象:
        11
      • 派生子类:
        12
  • 在外部类的外面使用非静态内部类(有难度)
    • 内部类:也叫寄生类
      • 静态内部类的实例,要寄生在外部类的类本身中。(因为是类成员属于类)
      • 非静态内部类的实例,要寄生在外部类的实例中。(因为是实例成员,属于类的实例)
    • 外部类:也叫宿主类
    • 用法:
      • 声明变量:
        外部类.非静态内部类 变量名;
      • 创建对象:
        宿主.new 非静态内部类的构造器(参数);
      • 访问类变量(只能是常量 publis static final)
        外部类.非静态内部类.类常量
      • 派生子类:
        extends 外部类.非静态内部类
        重点在子类的构造器第一行,一定要用如下的语法:
        宿主.super(参数)
      • 示例:
        • 先创建一个非静态内部类:
          8
        • 声明非静态内部类变量、创建非静态内部类对象、调用静态常量:
          9
        • 派生子类(super一定要放在构造器的第一行):
          10