代码块_final关键字_eclipse常用快捷键_内部类

继承

继承中的成员方法之间的关系：

1、子父类中出现同名的成员方法【常见】，子类在调用这个重名的成员方法时直接调用的是自己重写父类的方法。2、子父类中出现不同名的成员方法【不常见】

方法的重写：

就是子类出现了与父类相同声明的方法，子类中的方法体跟我们父类中的方法体不同

声明格式：@override 表示重写，覆盖，复写

在子类重写上面加上该注解，就能在编译阶段检查是否是重写的方法，如果不是直接报错

重写的定义：方法名相同，参数列表相同，返回值类型有关，并且相同

作用：就是不想再父类方法的基础上直接继承，所以需要重写对父类的方法进行改造完成自己的功能。

重写的注意事项：

1、private修饰的方法不能够被子类重写；2、静态方法也不能被子类重写，重写是针对对象的，就是针对非静态的方法；3、子类重写的权限必须要大于等于父类，因为子类本来就是对父类的加强

代码块

含义：就是用大括号包裹的代码，根据它的位置不同，修饰符不同，每一种代码块都有自己的机制和作用

罗列：局部代码块、构造代码块、静态代码块、同步代码块

局部代码块：

含义：就是定义局部（方法中）的代码块

作用：是将局部代码块中的定义的变量快速的回收

格式：

{

代码块中的内容；

}

注意事项：当我们在代码块中的操作进行完毕，代码块中的内容虽然被回收，但是不会影响我们操作（赋值、打印、计算）的痕迹

构造代码块：

含义就是定义在类中方法外的代码块。

作用：也是用于给成员变量进行赋值，，，与构造方法重复

不同点：

机制：1、由jvm虚拟机调用；2、就是在调用构造方法前去调用构造代码块；3、每次调用构造函数之前都会将构造代码块中的内容给构造方法；4、创建一次对象我们的构造代码块就执行一次

，，，创建哪个对象构造代码块就会给那个对象一次，，，

静态代码块

含义：就是被static修饰的代码块

声明位置：在类中方法外

作用：用于只需要一次执行的代码

机制：就是随着类的信息的加载而加载

public class Demo07_静态代码块 {

	public static void main(String[] args) {
		System.out.println("主方法执行");
		show();
	}
	public static void show() {
		System.out.println("静态方法执行");
		Zi3 z = new Zi3();
		//主类先执行静态资源，然后调用show方法
		//等号左边先执行父类的静态资源，再执行子类的静态资源
		//等号右边创建对象：要执行子类的空参对象，
		//首先执行父类的构造代码块，再去父类的空参构造
		//再去子类，先执行子类的构造代码块，最后子类的构造代码块
		System.out.println("--------------");
		Zi3 z1 = new Zi3();
		//父类的静态资源已经加载过了
		//每加载一次调用一次构造代码块
	}
}
class Fu3{
	int a;
	static {
		System.out.println("父类的静态代码块");
	}
	{
		System.out.println("父类的构造代码块");
	}
	public Fu3() {
		System.out.println("父类空参构造");
	}
	public Fu3(int a) {
		System.out.println("父类的有参");
	}
}
class Zi3 extends Fu3{
	static {
		System.out.println("子类的静态代码块");
	}
	{
		System.out.println("子类的构造代码块");
	}
	public Zi3() {
		this(1);
		System.out.println("子类的空参");
	}
	public Zi3(int a) {
		//super(1);
		System.out.println("子类的有参");
	}
}

final关键字

修饰类

当final修饰类之后这个类就无法再去改变

被final修饰的类不能被继承

修饰方法

final修饰的方法不能被重写

修饰变量

1、被final修饰的变量的值无法在被改变，也就是常量

定义常量的格式 public static final 数据类型 常量名（命名规范一般所有的字母都是大写，单词跟单词之间需要用到_隔开） = 值

2、被final修饰引用数据类型的变量 不能去修改引用数据类型的地址值，但是其中数据可以被修改

3、成员变量的初始值

1、默认初始话 2、显示初始化 3、构造初始化

初始化的时机：就是构造方法执行结束前必须要给final修饰的成员变量赋值

eclipse中常用的快捷键

内容辅助键：

alt+/                   

使用这个快捷键可以帮助我们自动生成代码

使用配合：

main+alt+/  自动生成主方法

数组+alt+/   自动对数组进行遍历

syso+alt+/  直接生成系统打印语句

常用快捷键：

Ctrl+n: 表示新建工程 包 类

Ctrl+d 将选中的内容删除

Ctrl+/  快速进行单行注释  快速取消单行注释

Ctrl+o  查找当前类中的内容

Ctrl+1 在当前的代码上做出错误的提示

Alt+↑选中的代码向上移动一行

Alt+↓选中的代码向下移动一行

Ctrl+alt+↑选中的代码向上复制

Ctrl+alt+↓选中的代码向下复制

Ctrl+shift+f:将代码自动的排版

Ctrl+shift+o: 自动导包并且将无用inport删除

Ctrl+shift+t 搜索类型

alt+shift+r: 重命名

Alt+shift+s：生成源码相关的内容

F2 查看类名

F3或者ctrl+鼠标左键 查看源码

快速生成一个自定义类

Alt+shift+s  c 生成父类中的有的构造方法

Alt+shift+s  o生成本类中的成员的构造

Alir+shift+s v 重写父类的方法

Alt+shift+s  s 生成toString方法

Alt+shift+s  h 生成hashcode方法和equals方法

Alt+shift+s  r 生成get和set方法

内部类

含义：就是在一个类中去定义一个类

分类：

书写位置的分类：

成员内部类：普通成员内部类；私有成员内部类；静态成员内部类

局部内部类：

以命名的形式进行分类：有名字的内部类；匿名内部类

普通成员内部类：

定义位置：类中方法外

定义格式：跟类的定义相同位置发生了改变

class 类名{

}

访问：1、内部类可以直接访问外围类的成员，并且私有成员也可以直接访问；2、外围类中无法直接访问内部类的成员；3、外围类中需要访问内部类的成员可以通过创建内部类的对象来访问内部类的成员；4、外围类中可以访问内部的私有成员，内部的私有成员的修饰是无效的

创建成员内部类的格式：

外围类.内部类 对象名 = new 外围类().new 内部类();  Body.Heart bh = new Body().new Heart();

public class Demo10_普通成员内部类 {

	public static void main(String[] args) {
		Body.Heart bh = new Body().new Heart();
		bh.showMsg();
		Body n = new Body();
		n.show();
	}
}
class Body{
	private int height = 180;
	class Heart{//内部类
		private int beats = 100;//内部类私有无效
		public void showMsg() {
			System.out.println(height+"..."+beats);
		}
	}
	public void show() {
		System.out.println(height);
		//System.out.println(beats);外围类无法访问内部的成员
		Heart h = new Heart();
		System.out.println(h.beats);
	}
}

私有成员内部类

定义位置：类中方法外 要加上private修饰

被修饰之后的内部类在其他的类中的是无法访问的。

声明格式：

Private class 类名{

}

访问：无法在外部中的类在去访问私有的成员内部类 ，也无法去获取它的引用。

可以通过外围类创建私有成员内部类的对象来访问他的成员。

public class Demo11_私有成员内部类 {//外部类

	public static void main(String[] args) {
		Body1 b1 = new Body1();
		b1.show();
		//无法在外部中的类在去访问私有的成员内部类 ，也无法去获取它的引用。
		//Body1.Shen bs = new Body1().new Shen();
	}
}
class Body1{//外围类
	private int height = 187;
	private class Shen{
		int age = 18;
		public void showMsg() {
			System.out.println("我是肾");
		}
	}
	public void show() { 
		System.out.println(height);
		//可以通过外围类创建私有成员内部类的对象来访问他的成员。
		Shen s = new Shen();
		System.out.println(s.age);
		s.showMsg();
	}
}

静态成员内部类

位置：类中方法外

定义格式：

Static class 类名{

}

访问：1、无法在一个静态的环境下直接访问外围中非静态的成员；2、是否创建对象取决于要访问的资源是否是静态的。

创建成员内部类的格式：Body2.Gan bg = new Body2.Gan();

public class Demo12_静态内部类 {

	public static void main(String[] args) {
		Body2.Gan bg = new Body2.Gan();
		bg.showMsg();
		Body2 b = new Body2();
		b.show();
	}
}

class Body2{//类中
	private static int height = 18;
	static class Gan{//静态成员内部类
		String color = "black";	//不是静态	
		public void showMsg() {//方法外    不是静态
			System.out.println(height);//无法在一个静态的环境下直接访问外围中非静态的成员。
			System.out.println(color+"大哥别喝了");
		}
	}
	public void show() {
		Gan g = new Gan();		
		System.out.println(g.color+"肾");
		System.out.println(height);//非静态的可以访问静态的，静态的不能访问非静态的
	}
}

局部内部类

位置 在方法中定义

定义的格式

Class 内部类名{

}

访问：1、外界无法去获取到局部内部类中的成员；2、外界也无法获取局部内部类的引用

解决方案：

通过方法中定义内部类的引用对象，这个对象去调用内部类中的成员。

通过外界的方法再去调用这个方法才能够访问内部类中的成员。