五、高级类特性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(){
重写方法();
}
}
}