DAY10-final关键字、代码块、抽象类、接口、包、访问权限修饰符、内部类

一、final关键字

1.我们先来想想常量有哪些？

• 字面值常量：
  • 整数常量
  • 小数常量
  • 字符常量
  • 字符串常量
  • 布尔常量(boolean)
  • 空常量（null)
• 自定义常量:
  • 被final所修饰的变量就是自定义常量

2.那么什么是final关键字呢？

首先它是一个修饰符，代表最终的意思，分别可以修饰类，变量和方法；

3.final关键字的特点有哪些？

1. 被final所修饰的类，不能被继承
2. 被final所修饰的变量，就是自定义常量
   给被final所修饰的变量赋值，有两种方案：
   a. 显示初始化
   b. 有参构造方法初始化
3. 被final所修饰的方法，不能被重写

二、代码块

1.什么是代码块？

由{}括起来的就称为代码块。

2.代码块的分类？

1. 局部代码块
2. 构造代码块
3. 静态代码块
4. 同步代码块(待补充)

2.1 局部代码块

• 什么是局部代码块？
  • 定义在方法中的代码块就是局部代码块。
• 局部代码块的作用？
  • 能够让局部变量尽早的内存中消失，节省内存空间。

2.2 构造代码块

• 什么是构造代码块？
  • 定义在类中方法外的代码块就是构造代码块。
• 构造代码块的作用？
  • 构造方法是在创建对象的时候执行，并且是优先于构造方法执行的。
  • 可以将构造方法中的共性内容进行抽取，放入到构造代码块中。

2.3 静态代码块

• 什么是静态代码块？
  • 在构造代码块前面加上static关键字，就成了静态代码块
• 静态代码块的作用？
  • 静态代码块只会在字节码文件加载进行方法区的时候，执行一次。
  • 静态代码块在第一次创建对象的时候执行，之后不管创建多少次对象，都不会再执行了。
  • 静态代码块就是给程序中的一些重要的变量进行初始化的，只需要初始化一次，之后再也不用初始化了。

三、抽象类

1. 什么是抽象类？

• 有抽象方法的类就是抽象类
• 被abstract关键字所修饰的类就是抽象类

2. 什么是抽象方法？

• 没有方法体的方法就是抽象方法
  public void eat();//没有方法体

3. 抽象类的特点？

1. 抽象类和抽象方法都要由abstract关键字修饰

abstract class Aniaml {
	public abstract void eat();
}

2. 抽象类中可以没有抽象方法，但是有抽象方法的类一定是抽象类

abstract class Animal {
	public void eat() {	
	}	
	public abstract void drink();
}

3. 抽象类不能创建对象
4. 一个类如果想要继承抽象类，要么该类也是一个抽象类，可以不重写抽象方法，要么该类是一个普通类，就必须重写所有的抽象方法

  abstract class Fu {
	public abstract void eat();
	public abstract void drink();
  }
  
  abstract class Zi extends Fu {
	
  }
  
  ---------------------------------
  
  class Zi extends Fu {
	@Override
	public void eat() {
	
	}
	
	@Override
	public void drink() {
	
	}
  }

4. 抽象类的成员特点？

1. 成员变量：
   1.1 可以有静态的成员变量。
   1.2 可以有非静态的成员变量。
   1.3 可以有被final修饰的自定义常量。
2. 成员方法：
   2.1 可以有非抽象的成员方法。
   2.2 可以有抽象的成员方法。
3. 构造方法：
   3.1 有构造方法，为了给抽象类中的成员变量进行初始化的，提供给子类使用。

abstract class Fu {
	int i;
	
	public Fu() {
	
	}
}

class Zi extends Fu {
	public Zi() {
		super();
	}
}

5. abstract关键字不能和哪些关键字共存？

1. 不能和private共存？
   被private修饰的方法不能被重写，但是被abstract修饰的方法必须被子类重写
2. 不能和final共存？
   被final修饰的方法不能被重写，但是被abstract修饰的方法必须被子类重写
3. 不能和static共存？
   被static修饰的方法可以通过类名直接调用，但是被abstract修饰方法没有方法体

6. 我们什么时候可以使用抽象类？

1. 在子父类继承中，如果父类中的方法不需要强制子类重写，可以将父类定义为普通父类即可。
2. 如果父类中的方法必须强制子类重写的话，就可以将父类定义为抽象父类，方法定义为抽象方法。

abstract class Animal {
	public abstract void eat();
	public abstract void sleep();
	
	public void drink() {
		System.out.println("喝水");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("吃骨头");
	}
	
	public void sleep() {
	
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("吃鱼");
	}
	
	public void sleep() {
	
	}
}

四、接口

1. 什么是接口？

• 比抽象类更加抽象的表现形式，就是接口

2. 接口的定义格式？

• 定义接口用interface

interface 接口名 {
	
	}

注意：接口不是类！

3. 接口的使用格式？

interface Inter {
		
		}
class InterImpl implements Inter {
		
		}

4. 接口的特点？

1. 接口不能创建对象。
2. 一个类想要实现一个接口，要么该类是一个抽象类，可以不重写接口中的抽象方法，要么该类是一个普通类，就必须重写接口中的所有的抽象方法。

5. 接口的成员特点？

1. 成员变量：接口所有的成员变量都是自定义常量
2. 默认修饰符：public、static、final

interface Inter {
	//public static final int i = 10;
	//static final int i = 10;
	//final int i = 10;
	int i;
}

3. 成员方法：接口中的所有的方法都是抽象方法(JDK 8 以前)，默认修饰符：public、abstract

interface Inter {
	public abstract void aaa();
	abstract void bbb();
	void ccc();
}

4. 构造方法：接口中没有构造方法

6. 类与类，类与接口，接口与接口之间的关系？

1. 类与类之间是继承关系：只支持单继承，不可以多继承，可以多层继承，不可以循环继承

2. 类与接口之间是实现关系：支持单实现，可以多实现，也可以在继承一个类的同时实现多个接口

3. 接口与接口之间是继承关系：支持单继承，可以多继承

7. 我们什么时候可以使用接口？

• 接口是额外扩展的功能，也就是说本身该类不具备这个功能，想要具备就要找一个具有该功能接口即可.
• 当类与接口之间存在"like a"关系的时候，就可以实现

举例：

public class Demo04 {
	public static void main(String[] args) {
		Pig pig = new Pig();
		pig.eat();
		pig.drink();
		pig.sleep();
		pig.fly();
		pig.swimming();
	}
}

abstract class Animal {
	public abstract void eat();
	
	public void drink() {
		System.out.println("喝水");
	}
	
	public abstract void sleep();
}

class Dog extends Animal {
	public void eat() {
		System.out.println("吃骨头");
	}
	
	public void sleep() {
		System.out.println("趴着睡");
	}
	
	public void swimming() {
		System.out.println("狗刨");
	}
}

class Cat extends Animal {
	public void eat() {
		System.out.println("吃鱼");
	}
	
	public void sleep() {
		System.out.println("躺着睡");
	}
	
	public void swimming() {
		System.out.println("猫刨");
	}
}

class Pig extends Animal implements Aircraft, Swim {
	public void eat() {
		System.out.println("吃肉");
	}
	
	public void sleep() {
		System.out.println("站着睡");
	}
	
	public void fly() {
		System.out.println("横着飞");
	}
	
	public void swimming() {
		System.out.println("猪刨");
	}
}

class Bird extends Animal {
	public void eat() {
		System.out.println("吃虫子");
	}
	
	public void sleep() {
		System.out.println("倒着睡");
	}
	
	public void fly() {
		System.out.println("飞");
	}
}

interface Aircraft {
	public void fly();
}

interface Swim {
	public void swimming();
}

五、包

1.什么是包？

• 本质就是文件夹

2. 怎么创建包？

• 文件夹与文件夹之间要用 “.” 隔开
  例如：
  com.aaa
  com.bbb

3. 包的命名规则是？

• 一般都是公司域名倒着写，去掉www
  www.crystal.com
  com.crystal.xxxooo
  注意：包名都是小写的

4. 怎么导包？

• 导包要用关键字import

import java.util.Scanner;

5. 为什么要导包？

• 因为类与类之间不再一个包中，想要找到另外一个类，就得需要导包

六、访问权限修饰符

public > protected > 默认的 > private

修饰符	同类	同包不同类有继承	同包不同类无继承	不同包不同类有继承	不同包不同类无继承
public	true	true	true	true	true
protected	true	true	true	true	false
默认的	true	true	true	false	false
private	true	false	false	false	false

• 以后我们写一个类，类中的各个组成部分都用什么访问权限修饰符呢？
  1. 类一般都用public修饰，一个Java文件中只写一个类
  2. 成员变量一般都用private修饰，封装
  3. 成员方法一般都用public修饰
  4. 构造方法一般都用public修饰

七、内部类

1. 什么是内部类？

• 在类中定义的类，就称为内部类

2. 内部类的特点？

• 内部类可以直接访问外部类的成员，包括私有
• 外部类不能直接使用内部类的成员

3. 内部类的分类？

a.成员内部类：

1. 什么是成员内部类？
   定义在类中方法外的内部类就是成员内部类

class Outer {
	class Inner {
	
	}
}

• 被public/protected/默认的修饰：

class Outer {
	class Inner {
		int i = 1;
		
		public void show() {
			System.out.println("约吗");
		}
	}
}
class Demo {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		System.out.println(oi.i);
		oi.show();
	}
}

• 被static修饰的：

class Outer {
	static class Inner {
		int i = 1;
		
		public void show() {
			System.out.println("约吗");
		}
	}
}
				
class Demo {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer.Inner();
		System.out.println(oi.i);
		oi.show();
	}
}

• 被private修饰的：

class Outer {
	private class Inner {
		int i = 1;
		
		public void show() {
			System.out.println("约吗");
		}
	}
	
	public void print() {
		Inner inner = new Inner();
		System.out.println(inner.i);
		inner.show();
	}
}
				
class Demo {
	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.print();
	}
}

b.局部内部类：

• 什么是局部内部类？
  定义在方法中的内部类就是局部内部类

class Outer {
	public void print() {
		class Inner {
		
		}
	}
}