Java入门2.3---面向对象的主线3---其他的关键字：this、super、import、package、abstract、static、final、interface等

关键字修饰范围总结：

  类 属性 方法 构造器 代码块 内部类
private   √ √ √    
default √ √ √ √    
protected   √ √ √    
public √ √ √ √    
this   √ √ √    
super   √ √ √    
static   √ √   √ √
final √ √ √      
abstract √   √      

abstract不能修饰属性、构造器、不能与final static private共用。

一、this

修饰属性、方法、构造器

表示：当前对象或当前正在创建的对象

二、super

修饰属性、方法、构造器

表示：显示的调用父类的相应的结构，尤其是子父类有重名的方法、属性

三、import

  1. 显示导入指定包下的类或接口；
  2. 写在包的声明和源文件之间；
  3. 如果需要引入多个类或接口，那么就并列写出；
  4. 如果导入的类是java.lang包下的，如：System String Math等，就不需要显示的声明。
  5. 理解.*的概念，比如java.util.*；
  6. 如何处理同名类的导入，如：在util包和sql包下同时存在Date类；
  7. import static 表示导入指定类的static的属性或方法。
  8. 导入java.lang.*只能导入lang包下的所有类或接口，不能导入lang的子包下的类或接口。

四、package

声明源文件所在的包，写在程序的第一行。
每“.”一次，表示一层文件目录。

五、abstract

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

1.abstract修饰类 ，抽象类

（1）不可被实例化

（2）抽象类有构造器（凡是抽象类，都有构造器）【保证在创建类的实例时，有实例化的过程】

（3）抽象方法所在的类，一定是抽象类

（4）抽象类中可以没有抽象方法

2.abstract修饰方法，抽象方法

（1）格式：只有方法的声明，没有方法的实现。以分号结束，如，public abstract void eat();

（2）抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写抽象方法

（3）若子类继承抽象类，并重写了所有的抽象方法，则此类是一个“实体类”，即可以实例化

（4）若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的

3.abstract不适用的场景

不能用abstract修饰：

  1. 属性
  2. 构造器：构造器不能被重写
  3. private方法：子类不能覆盖（或重写）声明为private的方法
  4. 静态方法：静态方法意味着可以通过类来直接调用，当声明为抽象时，又没有方法体。
  5. final方法：final与abstract矛盾

4.模板方法设计模式（TemplateMethod）

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

解决的问题：

  1. 当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
  2. 编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

六、static

static：可以用来修饰属性、方法、代码块（或初始化块）、内部类

1.static修饰属性（类变量）

  1. 由类创建的所有的对象，都共用这一个属性；
  2. 当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。 VS 实例变量（非static修饰的属性，各个对象各自拥有一套副本）
  3. 类变量随着类的加载而加载的，而且独一份。
  4. 静态变量可以直接通过“类.类变量”的形式来调用。（实例变量：随着对象的创建而被加载的，所以静态变量加载时间要早于实例变量。）
  5. 类变量的加载要早于对象。所以当有对象以后，可以“对象.类变量”调用，但是“类.实例变量”是不行的。
  6. 类变量存在于静态域中。

举例：

2.static修饰方法（类方法）

  1. 随着类的加载而加载，在内存中也是独一份；
  2. 可以直接通过“类.类方法”的方式调用。
  3. 在静态方法内部，可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态方法。（原因：生命周期不同）
  4. 静态的方法内是不可以有this或super关键字的！！！（在调用当前static方法时，可能没有生成对象，不能用this.方法）

注：静态的结构（static的属性、方法、代码块、内部类）的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构。

3.设计模式及单例模式的饿汉式和懒汉式

3.1 设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。

  1. 单例的设计模式：使得一个类只能够创建一个对象。

3.2 单例模式---饿汉式（线程安全）

public class TestSingleton{
	public static void main(String[] agrs){
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1 == s2);
	}
}

class Singleton{
	// 1.私有化构造器，使得在类的外部不能够调用此构造器
	private Singleton(){
	
	}
	// 2.在类的内部创建一个类的实例
	private static Singleton instance = new Singleton();
	// 3.私有化此对象，通过公共的方法来调用
	// 4.此公共的方法，只能通过类来调用，因此设置为static，同时类的实例也必须为static声明的
	public static Singleton getInstance(){
		return instance;
	}
	
}

Java.lang包下面的runtime类用的是饿汉式单例模式

3.3 单例模式---懒汉式（线程不安全）

用的时候再创建

// 2.懒汉式
public class TestSingleton{
	public static void main(String[] agrs){
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1 == s2); // true
	}
}

class Singleton{
	// 1.私有化构造器，使得在类的外部不能够调用此构造器
	private Singleton(){
	
	}
	// 2.在类的内部创建一个类的实例
	private static Singleton instance = null;
	// 3.此公共的方法，只能通过类来调用，因此设置为static，同时类的实例也必须为static声明的
	public static Singleton getInstance(){
		if (instance == null){
			instance = new Singleton();
		}
		return instance;
}　　

4.main方法

 

七、final

在Java中声明类、属性和方法时，可使用关键字final来修饰，表示“最终”。

Final类型变量初始化

  1. 没有static修饰：只能在定义处、初始化、构造函数三处选一处进行初始化，初始化后， 无法改变
  2. 有static修饰：只能在定义处、静态代码初始化块二选一，初始化后，无法改变，声明为 final 的局部变量必须（且只能）在使用前初始化一次，不使用的话可不必初始化

1.final修饰的类不能被继承

提高安全性，提高程序的可读性。如：String类、System类、StringBuffer类

2.final修饰的方法不能被子类重写

如：Object类中的getClass()

3.final修饰的变量（成员变量或局部变量）称为常量

习惯上，常量用大写字符表示，且只能被赋值一次。此常量在哪里赋值：

  1. 此常量不能使用默认初始化；
  2. 可以显示的赋值、代码块、构造器，不能在方法中赋值。

变量用static final修饰，为全局常量。

与finally finalize()区别

八、interface

1.接口是什么？

有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。接口是与类并行的一个概念。

  1. 接口是抽象方法和常量值的定义的集合。
  2. 从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量（所有的常量都用public static final修饰）和方法的定义（抽象方法：所有的都用public abstract修饰），而没有变量和方法的实现。
  3. 接口是没有构造器的
  4. 接口定义的就是一种功能，此功能可以被类所实现（implements），比如，class CC implements AA
  5. 实现接口的类，必须要重写其中的所有抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类。
  6. 类可以实现多个接口-------Java中的继承是单继承的
  7. 接口与接口之间也是继承的关系，而且可以实现多继承。

实现接口类：class Subclass implements InterfaceA{}

 

2. 接口用法总结

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

3.接口应用

3.1  工厂方法（FactoryMethod）

定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。

适用性：

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

举例：Work继承IWorkFactory接口，实际是TeacherWork调用StudentWorkFactory，StudentWork调用TeacherWorkFactory

 

3.2 代理模式（Proxy）

为其他对象提供一种代理以控制对这个对象的访问。 

 

posted @ 2020-06-01 23:03  nxf_rabbit75  阅读(262)  评论(0)    收藏  举报