回顾static、super、代码块、继承、重写等概念

前言：本文主要介绍有关static、super、代码块、继承、重写等相关知识点。

1.static

直译：静态的，可以修饰成员变量和成员方法。

有关static的特点总结如下：
1.static修饰变量又称为共享变量,类变量,静态变量
2.静态成员属于某一类的,而不属于某一个具体的对象
3.访问静态成员的方式:
a.通过对象访问 不建议
b.通过类名访问
c.通过读写方法访问
4.静态static关键字可以修饰变量,还能够修饰方法,同时还可以修饰代码块(后面讲)
5.static修饰的方法称为类方法,方法体内部称为静态环境/静态上下文
a.非静态环境可以访问静态变量
b.静态环境下只能够访问静态变量
c.静态环境下不能够出现this,super(后面讲)
6.静态修饰方法的意义? – 简化代码
a.静态方法用来访问静态成员
b.编写工具类
1.构造方法私有
2.成员方法添加static关键字修饰
Arrays 工具类 Math 工具类
7.static还可以修饰类,但是必须是内部类(后面讲解)
8.static的内存图
static是共享的,不变的,放在方法区,静态代码块在类加载的时候就会执行,并且只执行一次。

static修饰与非static修饰的区别：

2.代码块

概念:使用”{}”括起来的一段代码
分类：根据位置可分类
1.局部代码块: 定义在局部位置,限定局部变量的作用域
2.构造代码块: 定义在成员位置,抽取多个构造代码块的重复代码,从而简化代码
在每次构造方法之前执行,并且可以执行多次
3.静态代码块: 定义在成员位置 使用**"static"声明的代码块
在类加载的时候执行,只能够执行一次
可理解为在类第一次出现的时候加载或者类的成员被访问的时候加载
作用:
a.初始化静态成员
b.资源文件的读写,以及配置文件的读写,以及连接资源的载入等等
数据库连接
读取配置文件
4.同步代码块: 定义在局部**位置
构造方法、构造代码块、静态代码块的执行顺序?
静态代码块 > 构造代码块 > 构造方法
静态代码块在类加载的时候执行只执行一次
构造代码块在每次访问构造方法之前执行,可以执行多次
构造方法每次创建对象的时候执行,可以执行多次

 	      class CodeBlock {
	int x;
	int y;
	static int z;	
	{
//		System.out.println("CodeBlock 构造代码块");
		print();
	}
	public CodeBlock() {
//		print();
		System.out.println("我是无参构造方法");
	}	
	static {
		System.out.println("我是静态代码块");
		z = 100;
	}
	public CodeBlock(int x, int y) {
//		print();
		this.x = x;
		this.y = y;
		System.out.println("我是带参构造方法");
	}
	public void print() {
		System.out.format("(%d,%d)%n", x, y);
	}
	public void method() {
		int num = 10;
		// 局部代码块
		{
			int a = 20;
			System.out.println(num);
			System.out.println(a);
		}
		int a = 30;	
		// 同步代码块
		synchronized(new Object()){			
		}		
	}
}*/

/*
public class StaticDemo03 {
	public static void main(String[] args) {
		CodeBlock.country = "中国";
		CodeBlock cb = new CodeBlock();
		CodeBlock cb2 = new CodeBlock();
	}
	
	static {
		System.out.println("StaticDemo03 的静态代码块01");
	}
	
	static {
		System.out.println("StaticDemo03 的静态代码块02");
	}
}

class CodeBlock {
	static String country;
	
	static {
		System.out.println("CodeBlock 静态代码块1");
	}
	
	{
		System.out.println("CodeBlock 构造代码块1");
	}
	
	static {
		System.out.println("CodeBlock 静态代码块2");
	}
	
	{
		System.out.println("CodeBlock 构造代码块2");
	}
	
	public CodeBlock() {
		System.out.println("CodeBlock无参构造方法");
	}	
}

结果为：

* StaticDemo03 的静态代码块01
 * StaticDemo03 的静态代码块02
 * 
 * CodeBlock 静态代码块1
 * CodeBlock 静态代码块2
 * 
 * CodeBlock 构造代码块1
 * CodeBlock 构造代码块2
 * 
 * CodeBlock无参构造方法
 * 
 * CodeBlock 构造代码块1
 * CodeBlock 构造代码块2
 * 
 * CodeBlock无参构造方法
 */

3. 继承

概念 ：假设多个类存在相同属性和行为时，我们同样可以将这些内容抽取到单独的一个类中，那么这多个类没有必要再定义这些属性和行为，只需要继承这个单独的类就好了，这就是继承。

继承的格式:

• 类和类之间的关系:
• 1.继承 (is a)
• 2.组合 (has a)
• 通过extends关键字可以实现类与类的继承
• class 子类类名 extends 父类类名 {
• }
• 被继承的这个类称为父类，基类或者超类
• 继承的这个类称为子类或者派生类
• 继承的特点:
• 1.通过extends关键字,实现了继承之后,让类与类之间产生了关系,建立关系是好还是坏? 有好友坏
• 2.继承的本质就是抽取共性代码,多个重复代码的向上抽取,简化代码 BaseDao BaseActivity
• 3.类是对一批对象的抽象,继承是对一批类的抽象
• 4.父类又被称为超类,或者基类,子类又被称为派生类
• 5.Java是面向对象语言,万事万物皆是对象,为了满足这个设计原则,所有的类都直接或者间接继承自Object类
• 继承的好处:
• 1.简化了代码
• 2.提高了扩展性
• 3.提高了可维护性
• 开闭原则: 对扩展开放,对修改关闭
• 继承的缺点:
• 开闭原则: 对扩展开放,对修改关闭
• 高内聚,低耦合: 类与类之间,功能与功能之间,模块与模块之间,功能尽量内聚,不同模块之间,尽量独立
• 1.造成了耦合性过高,牵一发动全身
• 注意: 继承一定要慎用,主要利用继承简化代码的优点
• 继承的注意事项:
• 1.单一继承性
• 2.支持多层继承
• 3.如果父类成员使用private修饰,那么子类不能被继承
• 4.如果一个子类继承了父类的属性和方法还可以有自己特有的属性和方法
• 5.当子类和父类的成员变量重名的时候,子类优先
• 6.构造方法不能够被继承
• 什么时候使用继承?
• 1.一般在写代码的时候发现代码中存在重复代码,需要向上抽取,考虑继承
• 2.当某个类的设计非常复杂的时候可以考虑继承 例如: 设计一个窗口类
• 使用继承的步骤:
• 1.先写子类
• 2.观察多个子类是否存在共性代码
• 3.如果存在,抽取共性代码到父类中
• 4.子类继承父类
• 5.将子类共性代码删除
• 注意: 父类命名: A is a B
  */

4.super

super关键字
his和super的区别?

• this可以理解为当前对象,谁调用this就代指那个调用者对象,
  每次创建一个对象,默认都会创建一个this变量指向同一个堆区空间
  super本质是父类存储空间的标识,但是你可以理解为父类对象,
  那么同样可以使用super这个关键字来访问父类的成员

访问成员

•  成员变量
   	this.成员变量
   	super.成员变量
  

•  成员方法
   	this.成员方法
   	super.成员方法
  

•  构造方法
   	this(参数列表)
   	super(参数列表)
  

注意:
1.任何一个类的无参或者带参构造方法的第一句都默认省略 super();
2.任何一个类都直接或者间接继承自Object类
3.为什么设计Object类,满足了万事万物皆对象的原则
访问根类Object的无参构造方法的意义何在? - 加载Object类中静态成员和静态代码块
4.创建一个子类对象默认会去调用父类的构造方法,那么有没有在创建子类对象的同时也创建了父类对象呢?
– 没有创建父类对象,本质就相当于访问了一个普通方法,创建对象开启空间需要new关键字
5.super访问父类带参构造方法的意义? – 帮助子类初始化父类继承下来的成员,简化编程
6.静态环境/静态上下文(static修饰的方法),不能够出现this和super
7.super必须出现在构造方法的第一句
8.this和super不能够共存

 */
public class SuperDemo01 {
	public static void main(String[] args) {
//		Zi zi = new Zi();
//		Zi zi = new Zi("张三", 18, "北京西路");
		Fu fu = new Fu();
		System.out.println(fu.name + "|" + fu.age);
		/*
		 * 我是父类带参构造方法
		 * 我是父类无参构造方法
		 * "王五" 20
		 */
	}
}
class Fu extends Object {
	public String name;
	public int age;
	private double weight;	
	public Fu() {
		super();
//		this("王五", 20);
		System.out.println("我是父类无参构造方法");
	}
		public Fu(String name, int age) {
		System.out.println("我是父类带参构造方法");
		this.name = name;
		this.age = age;
	}	
	public void fuMethod() {		
	}	
	public static void staticMethod() {
	}
}
class Zi extends Fu {	
	private String address;
	
	public Zi() {
		super();
		System.out.println("我是子类无参构造方法");
	}	
	public Zi(String name, int age, String address) {
//		super();
//		System.out.println("我是子类带参构造方法");
//		this.name = name;
//		this.age = age;
		super(name, age);
		this.address = address;
	}	
	public void ziMethod() {
		System.out.println(super.name);
		this.fuMethod();
		super.fuMethod();
	}	
} 

5.访问权限修饰符

public [default] protected private

概述: 本质就是用来控制类中成员的访问权限,封装的核心

修饰类
public 任何包中的类都可以访问该类
默认(default) 同一个包中的类可以访问该类
不能用protected和private修饰类。
修饰成员（成员变量或者成员方法）
private 只对本身类可见
默认(default) 对同一包中的类可见
protected 对所有子类和同一包中的类可见
public 对一切类可见

6.方法重写

概述

如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写。

方法重写的特点:

• 1.发生在具有子父类的两个类中
• 2.方法名相同
• 3.参数列表完全相同
• 4.返回值类型可以相同或者是其子类
• 5.访问权限修饰符不能够严于父类

* 注意事项:

• 1.private修饰的方法不能够被继承,所以不能够被重写
• 2.构造方法不能够被重写
• 3.子类重写父类的方法时，访问权限修饰符不能更低，严格
• 4.返回值类型相同或者是其子类
• 5.重载和重写的区别(重写和重载是完全不同的两个概念毫无任何关系)
•