Java第五章高级类特性2

五、高级类特性2

 <1>static

static修饰变量

static,静态的，可以用来属性、方法、*代码块(或初始化块)、*内部类
static修饰属性(类变量)：
1.由类创建的所有的对象，都共用这一个属性。
2.当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs实例变量(非static修饰的属性，各个对象各自拥有一套剧本)(随着对象的加载而加载)
3.类变量随着类的加载而加载的，而且独一份。
4.静态的变量可以直接通过"类.类变量"的形式来调用。
5.类变量的加载要早于对象。所以当有对象以后，可以"对象.类变量"使用，但是"类.实例变量"是不行的。
6.类变量存在于静态域中。

 

static修饰方法

static修饰方法(类方法):
1.随着类的加载而加载，在内存中也是独一份
2.可以直接通过"类.类方法"的方式调用。
3.内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法可以调用静态的属性和方法。
>静态的方法内是不可以有this或super关键字的。
注:静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也晚于非静态结构

 

使用静态的变量可以实现"累加"的效果，因为静态的变量在内存中独一份

 

<2>设计模式

含义：设计模式在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思路(23种设计思路)

 

单例设计模式

1.解决问题:使得一个类只能够创建一个对象。                                       
2.如何实现？

饿汉式

 

//饿汉式
*只能创建singleton的单个实例
Singleton s1 = Singleton.getInstantce();
Singleton s2 = Singleton.getInstantce();
s1==s2//true
s1与s2只想锥空间的一个区域

class Singleton{
1.私有化构造器，使得在类的外部不能够调用此构造器
private Singleton(){

}
2.在类的内部创建一个类实例
private static Singleton instance = new Singleton();

3.私有化此对象，通过公共的方法来调用
4.此公共的方法，只能通过类来调用，因为设置为static的，同时类的实例也必须为static声明的
public static Singleton getInstance(){
    return isntance;
}
}

 

 

 

懒汉式

 

//懒汉式：可能存在线程安全问题
只用创建一个对象
*只能创建singleton的单个实例
Singleton s1 = Singleton.getInstantce();
Singleton s2 = Singleton.getInstantce();
s1==s2//true
s1与s2只想锥空间的一个区域

class Singleton{
1.私有化构造器，使得在类的外部不能够调用此构造器
private Singleton(){

}
2.在类的内部创建一个类实例
private static Singleton instance = null;

3.私有化此对象，通过公共的方法来调用
4.此公共的方法，只能通过类来调用，因为设置为static的，同时类的实例也必须为static声明的
public static Singleton getInstance(){
    if(instance ==null){
        isntance =new Singleton();
    }
    return instance;
}
}

 

 

 

 

模板方法设计模式

模板方法设计模式
解决问题：一部分确定，一部分不确定。

 

<3>类的第四个成员：初始化块(代码块)

类的第四个成员：初始化块(或代码块)
1.代码块如果有修饰的话，那么只能使用static。
2.分类
静态代码块：
1.里面可以输出语句
2.随着类的加载而加载，而且只被加载一次
3.多个静态代码块之间按照顺序结构执行
4.静态代码块的执行要早于非静态代码块的执行
5.静态的代码块种只能执行静态的结构(类属性.类方法)

非静态代码块：
1.可以对类的属性进行初始化操作
2.里面可以有输出语句
3.一个类中可以有多个非静态的代码块，多个代码块之间按照顺序结构执行
4.每创建一个类的对象，非静态代码块就加载一次。
5.非静态代码块的执行早于构造器

属性：

初始化块
{

}
static{

}

构造器

 

<4>final

final：最终的，可以用来修饰类、属性、方法

1.final修饰类：这个类就不能继承。如：String类,StringBuffer类，System类

2,final修饰方法：不能被重写。如：Object类的getClass()

3.final修饰属性，此属性就是一个常量，一旦初始化后，不可在被赋值。习惯上，常量用大写字符表示。
此常量在哪里复制：①此常量不饿能使用默认初始化②可以显式的赋值，代码块，构造器。

变量用static final修饰：全局变量

 

<5>abstract抽象

abstract：抽象的，可以用来修饰类、方法

1.abstract修饰类：抽象类
1）不可被实例化
2）抽象类有构造器(凡是类都有构造器)
3）抽象方法所在的类，一定是抽象类。
4）抽象类中可以没有抽象方法。

2.abstract修饰方法：抽象方法
1）格式：没有方法体，包括{},如：public abstract void eat（）；
2）抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。
3）若子类继承抽象类，并重写了所有抽象方法，则此类是一个 "实体类"，即可以实例化
4）若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的。

 

abstract 不能用来修饰属性，构造器，private，final，static

 

<6>interface

接口(interface)是与类并行的一个概念
1.接口可以看作是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。
2.接口师妹有构造器的
3.接口定义的就是一种功能。此功能可以被类所实现(implements).比如：class CC implements AA
4.实现接口的类，必须要重写其中的所有的抽象方法，方可实例化，若没有重写所有的抽象方法，则此类仍为一个抽象类。
5.类可以实现多个接口。--------java继承是单继承的
6.接口和接口之间也是继承关系，而且实现多继承

interface AA{
    常量：所有的常量都用public static final 修饰
    int i = 12；
    boolean FLAG = false；
    抽象方法：所有的都用public abstract 修饰
    void method1();
    void method2();
}

 

<7>接口的用法总结

接口用法总结
1.通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系。
2.通过接口可以指明多个类需要实现的方法，一般用于定义对象的扩张功能。
3.接口主要用于定义规范。解除耦合关系

 

<8>工厂方法FactoryMethod

工厂方法(FactoryMethod)
概述：
定义一个用于创建对象的接口，让子类决定实例化的那一个类。
FactoryMethod是一个类的实例化延迟到其子类。

适用性：
1.当一个类不知道它所必须创建的对象的类的时候
2.当一个类希望由它的子类来制定他所创建的对象的时候
3.当类将创建对象的职责委托给多个帮助子类的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

 

<9>接口的应用：代理模式

 

<10>第五个成员：内部类

含义：

类的第五个成员：内部类
1.相当于说，我们可以在类的内部在定义类。外面的类：外部类  里面定义的类：内部类
2.内部类的分类：成员内部类(声明在类内部且方法外的)  vs  局部内部类(声明在类的方法里)
3.成员内部类：
     3.1是外部类的一个成员：①可以有修饰符（4个）②static final🌂可以调用外部类的属性方法
    3.2具体类的特点：①abstract②还可以在其内部定义属性、方法、构造器
4.局部内部类

5.关于内部类：
①如何创建成员内部的对象
②如何区分调用内部类、外部类的变量
🌂局部内部类

 

成员内部类

 

成员内部类
创建静态内部类的对象，可以直接通过外部类调用静态内部类的构造器
Person.Dog d = new Person.Dog();
创建非静态内部类的对象，必须像创建外部类的对象，通过外部类的对象调用内部类的构造器
Person p = new Person();
Person.Bird b = p.new Bird();
可以在内部类调用外部类的方法
main{
    Person p = new Person();
    Person.Bird b = p.new Bird();
    b.setName("杜鹃")；
}
class Person{
    String name = "韩梅梅"；

    class Bird{
        String name = "黄丽"；
        public void setName(String name){
            sysout(name);//杜鹃
            sysout(this.name);//黄鹂
            sysout(Person.this.name);//韩梅梅
        }    
    }
}

 

 

 

 

局部内部类

 

局部内部类
class OuterClass{
    public void method1(){
        class InnerClass{
    
        }
    }
    方式一：
    public Comparable getCompararble(){
        1.创建一个实现Comparable接口的类：局部内部类
        class MyComparable implements Comparable{
            重写方法();
        }
    //返回一个实现类对象
    return new MyComparable();
    }
    方式二：
        public Comparable getCompararble(){
        //2.返回一个实现Comparable接口的匿名内部类的对象
            return new Comparable(){
                重写方法();
            }
        }
}