Java基础：8. static关键字、final关键字、继承和访问控制

最新推荐文章于 2024-05-21 22:13:42 发布

JiangTao_xlili

最新推荐文章于 2024-05-21 22:13:42 发布

阅读量169

点赞数

分类专栏：【笔记】Java基础文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/JiangTao_qjww/article/details/127220566

版权

【笔记】Java基础专栏收录该内容

19 篇文章 0 订阅

订阅专栏

目录

1 static关键字

1.1 基本概念

1.2 使用方式

1.3 构造块和静态代码块

1.4 单例设计模式的概念

1.5 单例设计模式的实现流程

1.6 单例设计模式的实现方式

2 继承

2.1 继承的由来

2.2 继承的概念

2.3 继承的特点

2.4 方法重写的概念

2.5 方法重写的原则

2.6 Java开发的常用工具

2.7 又见构造块与静态代码块

3 访问控制

3.1 常用的访问控制符

3.2 package语句的由来

3.3 包的定义

3.4 定义包的规范

3.5 包的导入

4 final关键字

4.1 基本概念

4.2 使用方式

4.3 常量的概念
1 static关键字
- 1.1 基本概念
  - 使用static关键字修饰成员变量表示静态的含义，此时成员变量由对象层级提升为类层级，也就是整个类只有一份并被所有对象共享，该成员变量随着类的加载准备就绪，与是否创建对象无关。
  - static关键字修饰的成员可以使用引用.的方式访问，但推荐类名.的方式。
- 1.2 使用方式
  - 在非静态成员方法中既能访问非静态的成员又能访问静态的成员。
    - (成员：成员变量 + 成员方法，静态成员被所有对象共享)
  - 在静态成员方法中只能访问静态成员不能访问非静态成员。
    - (成员：成员变量 + 成员方法，因为此时可能还没有创建对象)
  - 能访问：非静态->非静态 ; 非静态->静态; 静态 -> 静态;
  - 不能访问：静态-> 非静态；
  - 在以后的开发中只有隶属于类层级并被所有对象共享的内容才可以使用static关键字修饰。(不能滥用static关键字)
- 1.3 构造块和静态代码块
  - 构造块：
    - 在类体中直接使用{}括起来的代码块。
    - 每创建一个对象都会执行一次构造块。
    - 当需要在执行构造方法体之前做一些准备工作时，则将准备工作的相关代码写在构造块中即可，比如：对成员变量进行的统一初始化操作
  - 静态代码块：
    - 使用static关键字修饰的构造块。
    - 静态代码块随着类加载时执行一次。
    - 静态代码块会随着类的加载而准备就绪，会先于构造块执行，静态代码块-随程序加载执行一次
    - 当需要在执行代码块之前随着类的加载做一些准备工作时，则编写代码到静态代码块中，比如：加载数据库的驱动包等
  - 静态代码块（一次）->构造块（多次）->构造方法体（多次）
- 1.4 单例设计模式的概念
  - 在某些特殊场合中，一个类对外提供且只提供一个对象时，这样的类叫做单例类，而设计单例的流程和思想叫做单例设计模式。
- 1.5 单例设计模式的实现流程
  - 私有化构造方法，使用private关键字修饰。
  - 声明本类类型的引用指向本类类型的对象，并使用private static关键字共同修饰。
  - 提供公有的get方法负责将对象返回出去，并使用public static关键字共同修饰。
- 1.6 单例设计模式的实现方式
  - 单例设计模式的实现方式有两种：饿汉式 和 懒汉式，在以后的开发中推荐饿汉式。
  - ```
  /*
      编程实现Singleton类的封装
   */
  public class Singleton {
  	
  	// 2.声明本类类型的引用指向本类类型的对象，使用private static关键字共同修饰
  	//private static Singleton sin = new Singleton();  // 饿汉式
  	private static Singleton sin = null;               // 懒汉式
  	
  	// 1.私有化构造方法，使用private关键字修饰
  	private Singleton() {}
  	
  	// 3.提供公有的get方法负责将对象返回出去，使用public static关键字共同修饰
  	public static Singleton getInstance() {
  		//return sin;
  		if(null == sin) {
  			sin = new Singleton();
  		}
  		return sin;
  	}
  }
```
- ```
/*
    编程实现Singleton类的测试
 */
public class SingletonTest {
	
	public static void main(String[] args) {
		
		// 1.声明Singleton类型的引用指向该类型的对象
		//Singleton s1 = new Singleton();
		//Singleton s2 = new Singleton();

        //比较变量s1的数值是否与变量s2的数值相等  false
		//System.out.println(s1 == s2); 

		//Singleton.sin = null;  可以使得引用变量无效
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1 == s2); // true
	}
}
```
2 继承
- 2.1 继承的由来
  - 人【姓名和年龄(特征)】【吃饭和娱乐(行为)】
    - 教师
    - 工人
  - 图形【横纵坐标(特征)】【打印(行为)】
    - 圆
    - 矩形
- 2.2 继承的概念
  - 当多个类之间有相同的特征和行为时，可以将相同的内容提取出来组成一个公共类，让多个类吸收公共类中已有特征和行为而在多个类型只需要编写自己独有特征和行为的机制，叫做继承。
  - 在Java语言中使用extends(扩展)关键字来表示继承关系。如：
    - public class Worker extends Person{} - 表示Worker类继承自Person类
    - 其中Person类叫做超类、父类、基类。
    - 其中Worker类叫做派生类、子类、孩子类。
  - 使用继承提高了代码的复用性，可维护性及扩展性，是多态的前提条件。
- 2.3 继承的特点
  - 子类不能继承父类的构造方法和私有方法，但私有成员变量可以被继承只是不能直接访问。
  - 无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法，来初始化从父类中继承的成员变量，相当于在构造方法的第一行增加代码super()的效果。
  - 使用继承必须满足逻辑关系：子类 is a 父类，也就是不能滥用继承。
  - Java语言中只支持单继承不支持多继承，也就是说一个子类只能有一个父类，但一个父类可以有多个子类。
- 2.4 方法重写的概念
  - 从父类中继承下来的方法不满足子类的需求时，就需要在子类中重新写一个和父类一样的方法来覆盖从父类中继承下来的版本，该方式就叫做方法的重写（Override）。
  - 重写，overriding,是指在继承的情况下，子类中定义了与父类中具有相同型构的新方法，也就是子类重写了父类的方法。
  - 重载，overloading，是在同一个类中，定义了一个以上具有相同名称，但是有着不同型构的方法，在同一个类中是不允许定义多于一个具有相同型构的方法的。
- 2.5 方法重写的原则
  - 要求方法名相同、参数列表相同以及返回值类型相同，从Java5开始允许返回子类类型。
  - 要求方法的访问权限不能变小，可以相同或者变大。
  - 要求方法不能抛出更大的异常(异常机制)。
- 2.6 Java开发的常用工具
  - 文本编辑器（TE，Text Editor）
    - 记事本、Notepad++、Edit Plus、UltraEdit、…
  - 集成开发环境（IDE，Integrated Development Environment ）
  - Jbuilder、NetBeans、Eclipse、MyEclipse、IDEA、…
- 2.7 又见构造块与静态代码块
  - 先执行父类的静态代码块，再执行子类的静态代码块。
  - 执行父类的构造块，执行父类的构造方法体。
  - 执行子类的构造块，执行子类的构造方法体。
  - 依次顺序：静态优先（独立空间）、父类优先、构造块优先
    - SupetTest类中的静态代码块！
    - ==============SubSuperTest类中的静态代码块！
    - SupetTest类中的构造块！
    - SuperTest类中的构造方法体！
    - ==============SubSuperTest类中的构造块！
    - ==============SubSuperTest类中的构造方法体！
    - 改变代码顺序，不影响静态、构造块、构造方法体的执行顺序。
3 访问控制
- 3.1 常用的访问控制符
  - 注意事项
    - public修饰的成员可以在任意位置使用。
    - private修饰的成员只能在本类内部使用。
    - 通常情况下，成员方法都使用public关键字修饰，成员变量都使用private关键字修饰。
- 3.2 package语句的由来
  - 定义类时需要指定类的名称，但如果仅仅将类名作为类的唯一标识，则不可避免的出现命名冲突的问题。这会给组件复用以及团队间的合作造成很大的麻烦！
  - 在Java语言中，用包（package）的概念来解决命名冲突的问题。
- 3.3 包的定义
  - 在定义一个类时，除了定义类的名称一般还要指定一个包名，格式如下：
    - package 包名;
    - package 包名1.包名2.包名3...包名n;
    - 为了实现项目管理、解决命名冲突以及权限控制的效果。
- 3.4 定义包的规范
  - 如果各个公司或开发组织的程序员都随心所欲的命名包名的话，仍然不能从根本上解决命名冲突的问题。因此，在指定包名的时候应该按照一定的规范。
  - org.apache.commons.lang.StringUtil，其中StringUtils是类名而org.apache.commons.lang是多层包名，其含义如下：
    - org.apache表示公司或组织的信息（是这个公司（或组织）域名的反写）；
    - common 表示项目的名称信息；
    - lang 表示模块的名称信息。
- 3.5 包的导入
  - 使用import关键字导入包。
  - 使用import关键字导入静态成员，从Java5.0开始支持。
4 final关键字
- 4.1 基本概念
  - final本意为"最终的、不可改变的"，可以修饰类、成员方法以及成员变量。
- 4.2 使用方式
  - final关键字修饰类体现在该类不能被继承。
    - 主要用于防止滥用继承，如：java.lang.String类等。
  - final关键字修饰成员方法体现在该方法不能被重写但可以被继承。
    - 主要用于防止不经意间造成重写，如：java.text.Dateformat类中format方法等。
  - final关键字修饰成员变量体现在该变量必须初始化且不能改变。
    - 主要用于防止不经意间造成改变，如：java.lang.Thread类中MAX_PRIORITY等。
    - final 初始化：显性初始化，构造块初始化，构造方法体初始化。
- 4.3 常量的概念
  - 在以后的开发中很少单独使用final关键字来修饰成员变量，通常使用：public static final关键字共同修饰成员变量来表达常量的含义，常量的命名规范要求是所有字母都要大写，不同的单词之间采用下划线连。