Java第五章高级类特性2

骑猪看日落 2021-12-15 08:09 284阅读 0赞

**五、高级类特性2**

**<1>static**

**static修饰变量**

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

**![1642540-20190329134746120-122791888.png][]**

**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(){
                    重写方法();
                }
            }
    }

转载于:https://www.cnblogs.com/yangHS/p/10699719.html

[1642540-20190329134746120-122791888.png]: /images/20211214/50424a68e6394699934f5688967f223d.png