目录
一、包
1、什么是包？
2、建包的语法格式
3、导包
二、权限修饰符
1、什么是权限修饰符？
2、权限修饰符的分类和具体作用范围
3、学完权限修饰符具备能力
三、final
1、final的作用
2、final修饰变量注意事项
四、常量
1、常量的基本概述
2、常量做信息标准的分类
五、枚举
1、枚举概述
2、定义枚举的格式
3、枚举的特征
4、枚举使用场景演示
六、抽象类
1、抽象类的基础知识
2、抽象类的使用场景
3、抽象类的特征和注意事项
4、final和abstract是什么关系?
5、模板方法模式
什么时候使用模板方法模式
模板方法实现的步骤
模板方法解决了什么问题？
七、接口
1、什么是接口
2、接口的基本使用：被实现
3、接口与接口的关系：多继承
接口多继承的作用：
4、JDK8开始接口新增方法
1、默认方法 (实例方法)
2、静态方法
3、私有方法
5、接口的注意事项：
一、包
1、什么是包？
包是用来分门别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护。
2、建包的语法格式
package 公司域名倒写.技术名称。包名建议全部小写，且具备意义。
package com.itheima.this_super;3、导包
相同包下的类可以直接访问，不同包下的类必须导包才可以使用。
导包格式：
import com.itheima.this_super;
package com.itheima.day01_package;
import com.itheima.day01_package.test.Test1;
public class Test {
public static void main(String[] args) {
//相同包下的类可以访问
System.out.println(User.a);
//不同包下的类要导包
System.out.println(Test1.b);
//如果这个类中使用不同包下的相同的类名，此时默认只能导入一个类的包，另一个类要使用全名访问
com.itheima.day01_package.test2.Test1 test1 = new com.itheima.day01_package.test2.Test1();
}
}二、权限修饰符
1、什么是权限修饰符？
- 权限修饰符：用来控制一个成员能够被访问的范围。
- 可以修饰成员变量、方法、构造器、内部类，不同权限修饰符修饰的成员能够被访问的范围将受到限制。
2、权限修饰符的分类和具体作用范围
权限修饰符的四种作用范围，由小到大为：
private > 缺省(default) > protected > public
缺省：没有修饰符 (包访问权限)
继承了父类的类为子类。
3、学完权限修饰符具备能力
三、final
1、final的作用
- final关键字是最终的意思，可以修饰(类、方法、变量)。
- final修饰类：表明该类是最终类，不能被继承。
- final修饰方法：表明该方法是最终方法，不能被重写。
- final修饰变量：表示该变量第一次赋值后，不能再次被赋值(并需要赋值，但只能被赋值一次)。
变量分为：局部变量和成员变量。成员变量分为：实例成员变量和静态成员变量。
2、final修饰变量注意事项
- final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。
- final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的
//仍然可以修改指向对象的内容
final Teacher t = new Teacher("爱好");
t.setHobby("修改");四、常量
1、常量的基本概述
2、常量做信息标准的分类
例如在使用switch语句中，使用case1,case2表意不明，可以通过常量，定义有意义的常量赋值为1，2，使代码可读性好，实现了软编码。
五、枚举
1、枚举概述
枚举是java中的一种特殊类型。
枚举的作用：“是为了做信息的标志和信息的分类”。
枚举类是Java中的一种类，它有有限个不同实例对象，又叫多例模式
2、定义枚举的格式
3、枚举的特征
4、枚举使用场景演示
public class Test {
//定义方法调用这个枚举类
public enum EnumTest {
//枚举第一行必须罗列枚举类型的对象名称，建议全部大写
//可以定义多个对象
UP,DOWN,LEFT,RIGHT;
}
public static void move(EnumTest e){
switch (e) {
case UP:
break;
case DOWN:
break;
case LEFT:
break;
case RIGHT:
break;
}
}
//方法调用move方法的内容
public void d1(){
//通过枚举类名调用
move(EnumTest.UP);
}
}六、抽象类
1、抽象类的基础知识
在java中abstract是抽象的意思，可以修饰类或者成员方法。
abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。
快速生成抽象方法：alt+Enter。
//一个类如果定义了抽象方法，这个类必须声明成抽象类，否则报错
public abstract class Animal {
//抽象方法只有方法签名，不能声明方法体
public abstract void dog();
}抽象类就相当于一个雏形的模具，用来让其他子类来继承这个模具，在这个模具的基础上创建新的东西。
继承的子类必须对抽象父类进行方法重新，否则报错，除非子类也是抽象类。
//对抽象类Animal进行继承
public class Dog extends Animal{
//对抽象父类进行重写
@Override
public void run() {
System.out.println("狗跑得快");
}
}2、抽象类的使用场景
3、抽象类的特征和注意事项
- 类有的东西(成员变量、成员方法、构造器)，抽象类都有
- 抽象类中可以没有抽象方法，有抽象方法的类一定是抽象类
- 一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类
- 不能用abstract修饰变量、代码块、构造器
最重要的特征 ：得到了抽象方法，失去了创建对象的能力 (有得有失)
抽象就是不能创建对象。
4、final和abstract是什么关系?
互斥关系
final修饰类，类不能被继承；abstract修饰类，类必须被继承。
abstract定义的抽象方法必须让子类重写，final定义的方法不能被重写。
5、模板方法模式
什么时候使用模板方法模式
使用场景：当系统中出现同一个 功能在多处开发，而该功能中大部分代码是一样的，只有其中部分可能不同
模板方法实现的步骤
- 把功能定义成一个所谓的模板方法，放在抽象类中，模板方法中只定义通用且能确定的代码。
- 模板方法中不能决定的功能定义成抽象方法让具体子类去实现。
//定义一个模板
public abstract class Student {
//模板方法用final修饰更专业，不允许重写
public final void write() {
System.out.println("标题");
System.out.println("第一段");
/*
*正文部分(每个子类都要写的，每个子类写的情况不一样)
* 因此，通过模板方法模式把正文定义成抽象方法，交给
* 具体的子类来完成
*/
//正文
writeMain();
System.out.println("结尾");
}
protected abstract void writeMain();
}
//创建子类继承这个模板
public class MiddleWritting extends Student{
@Override
protected void writeMain() {
System.out.println("中学生正文");
}
}
//测试
public class Test {
public static void main(String[] args) {
MiddleWritting m = new MiddleWritting();
m.write();
}
}
//结果
标题
第一段
中学生正文
结尾模板方法建议使用final修饰，这样会更专业，因为模板方法是给子类直接使用的，不是让子类重写的，一旦子类重写了模板方法，则模板方法就失效了，因此加上final修饰可以防止子类重写模板方法。
模板方法解决了什么问题？
- 提高了代码的复用性
- 模板方法已经定义了通用结构，模板方法不能确定的部分定义成抽象方法，交给子类实现，因此，使用者只需要关心自己需要实现的功能即可。
七、接口
1、什么是接口
接口也是一种规范，约束设计方式。规范一定是要公开
public interface Demo {
//1、常量
String SCHOOL_NAME = "黑那";
//会自动生成 public static final String SCHOOL_NAME = "黑那";
//可以省略不写，但要知道他是常量
//2、抽象方法
//public abstract void run();
//也可以不写，默认会设置
void run();
}2、接口的基本使用：被实现
接口是用来被类实现(implements)的，实现接口的类称为实现类。实现类可以理解成所谓的子类。
接口可以被类单实现，也可以被多实现。
注意：
一个类实现接口，必须重写完全部接口的全部抽象方法，否则这个类需要定义成抽象类。
3、接口与接口的关系：多继承
- 类和类的关系：单继承。
- 类和接口的关系：多实现。
- 接口和接口的关系：多继承，一个接口可以同时继承多个接口。
接口多继承的作用：
规范合并，整合多个接口为同一个接口，便于子类实现。
4、JDK8开始接口新增方法
允许接口中直接定义带有方法体的方法。
1、默认方法 (实例方法)
- 类似之前写的普通实例方法：必须用default修饰
- 默认会public修饰，需要用接口的实现类的对象来调用
public interface Sport {
/* 1、默认方法（实例方法）
---必须使用default修饰,public可以省略
---默认方法，接口不能创建对象，这个方法只能过继给了实现类，由实现类的对象调用
*/
public default void run(){
System.out.println("跑得很快");
}
}
//实现类
class PingMan implements Sport {
//接口没有定义抽象类，所以实现类不用操作
}
//test
class Test{
public static void main(String[] args) {
PingMan p = new PingMan();
p.run();
}
}2、静态方法
- 默认会public修饰，必须用static修饰
- 接口的静态方法必须用本身的接口名来调用，不允许子类调用父类的静态方法。
public interface Sport {
/* 2、静态方法
---必须使用static修饰，默认用public修饰
---public可以省略
---接口的静态方法，必须接口名自己调用
*/
public static void run(){
System.out.println("java新增语法");
}
}
//实现类
class PingMan implements Sport {
//接口没有定义抽象类，所以实现类不用操作
}
//test
class Test{
public static void main(String[] args) {
//静态方法只能接口名自己调用
Sport.run();
}
}3、私有方法
- 就是私有的实例方法：必须使用private修饰，从JDK1.9才开始有。
- 只能在本类中被其他默认方法或者私有方法访问。
public interface Sport {
/* 2、私有方法(实例方法)
---jdk1.9开始
---必须是default修饰的实例方法
*/
public default void run(){
go();
System.out.println("跑得很快");
}
private void go(){
//必须在接口的内部才能被访问
System.out.println("开始跑");
}
}
//实现类
class PingMan implements Sport {
//接口没有定义抽象类，所以实现类不用操作
}
//test
class Test{
public static void main(String[] args) {
//静态方法只能接口名自己调用
PingMan p = new PingMan();
p.run();
}
}5、接口的注意事项：
- 接口不能创建对象(接口更加彻底的抽象)。
- 一个类实现多个接口，多个接口中有同样的静态方法不冲突。
- 一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
public class Comment {
public static void main(String[] args) {
//一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
Cat c = new Cat();
c.eat();
}
}
interface Food{
default void eat(){
System.out.println("接口中的吃");
}
}
class Animal{
public void eat(){
System.out.println("父类动物吃");
}
}
//相当于子类有一个亲爸和多个干爹
//亲爸必须放在干爹前，继承在前，实现在后
class Cat extends Animal implements Food{
}- 一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。
interface A{
default void go(){
System.out.println("AA");
}
}
interface B{
default void go(){
System.out.println("BB");
}
}
class C implements A,B{
@Override
public void go() {
//一个类实现了多个接口，多个接口中存在同名的默认方法
//子类只能使用自己重写的方法，无法使用A,B的go方法
}
}- 一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能继承。
interface A{
//有返回值的a方法
int a();
}
interface B{
//无返回值的a方法
void a();
}
class C implements A,B{
@Override
public int a() {
//存在接口冲突
}
}
