面向对象编程(下)

面向对象编程(下)

关键字：static

类属性、类方法的设计思想

• 类属性作为该类各个对象之间共享的变量。在设计类时,分析哪些属性不因对象的不同而改变，将这些属性设置为类属性。相应的方法设置为类方法
• 如果方法与调用者无关，则这样的方法通常被声明为类方法，由 于不需要创建对象就可以调用类方法，从而简化了方法的调用

使用范围：在Java类中，可用static修饰属性、方法、代码块、内部类

被static修饰后的成员具备以下特点：

1. 随着类的加载而加载
2. 优先于对象存在
3. 修饰的成员，被所有对象所共享
4. 访问权限允许时，可不创建对象，直接被类调用

在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构
static修饰的方法不能被重写

单例 (Singleton)设计模式

• 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、 以及解决问题的思考方式
• 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

饿汉式

//懒汉式暂时还存在线程安全问题，讲到多线程时，可修复
class Singleton {
    // 1.私有化构造器
    private Singleton() { 
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single = new Singleton();
    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        return single;
    }
}
//线程安全
class Singleton {
    private static Singleton instance = null;
    private Singleton(){}
    public static Singleton getInstance(){
        if(instance==null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance=new Singleton();
                } 
            }
        }
        return instance;
    }
}
public class SingletonTest{
    public static void main(String[] args){
        Singleton s1=Singleton.getInstance();
        Singleton s2=Singleton.getInstance();
        System.out.println(s1==s2);
    }
}

懒汉式

//懒汉式暂时还存在线程安全问题，讲到多线程时，可修复
class Singleton {
    // 1.私有化构造器
    private Singleton() {       
    }
    // 2.内部提供一个当前类的实例
    // 4.此实例也必须静态化
    private static Singleton single;
    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        if(single == null) {
            single = new Singleton();
        }
        return single;
    }
}

代码块

• 对Java类或对象进行初始化
• 一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块(static block)，没有使用static修饰的，为非静态代码块
• static代码块通常用于初始化static的属性

静态代码块：用static 修饰的代码块

1. 可以有输出语句
2. 可以对类的属性、类的声明进行初始化操作
3. 不可以对非静态的属性初始化
4. 若有多个静态的代码块，那么按照从上到下的顺序依次执行
5. 静态代码块的执行要先于非静态代码块
6. 静态代码块随着类的加载而加载，且只执行一次

非静态代码块：没有static修饰的代码块

1. 可以有输出语句
2. 可以对类的属性、类的声明进行初始化操作
3. 除了调用非静态的结构外，还可以调用静态的变量或方法
4. 若有多个非静态的代码块，那么按照从上到下的顺序依次执行
5. 每次创建对象的时候，都会执行一次。且先于构造器执行

关键字：final

• final标记的类不能被继承
• final标记的方法不能被子类重写
• final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次

抽象类与抽象方法

• 用abstract关键字来修饰一个类，这个类叫做抽象类
• 用abstract来修饰一个方法，该方法叫做抽象方法
• 含有抽象方法的类必须被声明为抽象类
• 抽象类不能被实例化，抽象类是用来被继承的
• 不能用abstract修饰变量、代码块、构造器
• 不能用abstract修饰私有方法、静态方法、final的方法、final的类

抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提 供具体实现的对象的类

接口(interface)

接口就是规范，定义的是一组规则
继承是一个"是不是"的关系，而接口实现则是"能不能" 的关系
接口的本质是契约，标准，规范
接口(interface)是抽象方法和常量值定义的集合

特点：

1. 用interface来定义
2. 接口中的所有成员变量都默认是由public static final修饰的
3. 接口中的所有抽象方法都默认是由public abstract修饰的
4. 接口中没有构造器
5. 接口采用多继承机制

语法格式：

//先写extends，后写implements
class Student extends Person implements Interface{ }

接口和抽象类之间的对比

Java 8中关于接口的改进

• Java 8中，你可以为接口添加静态方法和默认方法

  • 静态方法：使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体
  • 默认方法：默认方法使用 default 关键字修饰l;可以通过实现类对象来调用

• 若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突

  • 实现类必须覆盖接口中同名同参数的方法，来解决冲突

• 若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略

内部类(Inner class)

Inner class的名字不能与包含它的外部类类名相同

• 在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类
• Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称
  • 成员内部类（static成员内部类和非static成员内部类）
  • 局部内部类（不谈修饰符）、匿名内部类

成员内部类

• 成员内部类作为类的成员的角色：

  1. 和外部类不同，Inner class还可以声明为private或protected；
  2. 可以调用外部类的结构
  3. Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；

• 成员内部类作为类的角色：

  1. 可以在内部定义属性、方法、构造器等结构
  2. 可以声明为abstract类 ，因此可以被其它的内部类继承
  3. 可以声明为final的
  4. 编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）

非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员内部类中才可声明static成员
外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式
成员内部类可以直接使用外部类的所有成员，包括私有的数据
当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的

局部内部类

• 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号，以及数字编号。
• 只能在声明它的方法或代码块中使用，而且是先声明后使用。
• 局部内部类可以使用外部类的成员，包括私有的。
• 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。
• 局部内部类和局部变量地位类似，不能使用public,protected,缺省,private
• 局部内部类不能使用static修饰，因此也不能包含静态成员

class 外部类{
    方法(){
        class 局部内部类{
            
        }
    }
    {
        class 局部内部类{
            
        }
    }
}

匿名内部类

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例
一个匿名内部类一定是在new的后面，用其隐含实现一个接口或 实现一个类

1. 匿名内部类必须继承父类或实现接口
2. 匿名内部类只能有一个对象
3. 匿名内部类对象只能使用多态形式引用

new 父类构造器（实参列表）|实现接口(){
//匿名内部类的类体部分
}