目录
1.final关键字
1.1final是什么
最终的意思
1.2final修饰类
该类被称为最终类，特点是不能被继承了。
// 演示1:final修饰类 叫最终类 不能被继承
final class LiLianying{}
class LiGang extends LiLianying{}//报错1.3final修饰方法
该方法被称为最终方法，特点是不能被重写了。
//演示2:final修饰方法 叫最终方法 不能被重写
class ZZK{
public final void jiMi(){
System.out.println("重要的情报");
}
}
class ZSF extends ZZK{
// 方法不能被重写了
// public void jiMi() {
// System.out.println("变成擦屁股纸...");
// }1.4final修饰变量
该变量有且仅能被赋值一次。
// 演示3: final修饰变量 最终变量 指的是只能赋值一次
final int a = 10;//final修饰基本数据类型特点: 变量的数值不能变
// a = 20; 被final修饰的变量只能赋值一次1.5使用final需要注意什么
final修饰基本数据类型的变量，其存储的数据不能改变。final修饰引用类型的变量，其存储的地址不能改变，但是指向的对象内容可以改变。
//数组是引用类型 final修饰引用类型数据的特点: 变量的指向地址不能变,里面内容可以变
final int[] arr = new int[]{1,2,3};
System.out.println(arr);
// arr = new int[]{2,3,4};
// System.out.println(arr);
arr[1] = 5;2.单例设计模式
2.1是什么
是为了解决某个问题的方案
2.2作用
保证一个类对外只能产生一个对象。
2.3饿汉单例
拿对象时，对象早就创建好了。
步骤：
（1）私有构造
（2）定义一个类变量记住类的一个对象
（3）定义一个类方法返回对象
public class A {
// 创建 私有 构造器
private A() {
}
//创建私有类变量a
private static A a=new A();
//创建公共方法，返回变量
public static A instance(){
return a;
}
}public static void main(String[] args) {
A a1=A.instance();
A a2=A.instance();
System.out.println(a1);
System.out.println(a2);
}
2.4懒汉单例
拿对象时，才开始创建对象。
步骤：
（1）私有构造
（2）拿对象时，才开始创建对象。
（3）提供一个静态方法，保证返回的是同一个对象。
//懒汉式
public class B {
// 1、单例必须私有构造
private B(){
}
// 2、定义一个类变量量用于存储对象
private static B b;
// 3、提供一个类方法返回类的一个对象
public static B getInstance(){
if (b==null){
b=new B();
}
return b;
}
}public static void main(String[] args) {
B b1=B.getInstance();
B b2=B.getInstance();
System.out.println(b1);
System.out.println(b2);
} 
3.枚举
3.1是什么
是一个特殊的类。可以看做是包含特定对象的"集合",设定好之后该类型只包含特定个数的对象。
3.2可以表达什么
可以表达有固定数量的类型，比如季节，星期，性别,交通灯等....
3.3定义格式
修饰符 enum 枚举类名{
名称1，名称2...；
}
public enum A{
X,Y,Z;
}3.4特点
【1】枚举类中的第一行，只能写枚举类的对象名称，且要用逗号隔开。
【2】这些名称，本质是常量，每个常量都记住了枚举类的一个对象。
【3】枚举都是最终类，不可以被继承，枚举类都是继承java.lang.Enum类的。
【4】枚举类的构造器都是私有的（写不写都只能是私有的），因此，枚举类对外不能创建对象。
3.5使用场景
枚举类很适合做信息分类和标志。
控制方向场景
public enum Direction {
UP,DOWN,LEFT,RIGHT;
}public class Constant {
public static final int UP=1;
public static final int DOWN=2;
public static final int LEFT=3;
public static final int RIGHT=4;
}public static void main(String[] args) {
move(0);
System.out.println("==================");
move2(Direction.UP);
move2(Direction.DOWN);
move2(Direction.LEFT);
move2(Direction.RIGHT);
}
public static void move2(Direction direction){
switch (direction){
case UP:
System.out.println("上");
break;
case DOWN:
System.out.println("下");
break;
case LEFT:
System.out.println("左");
break;
case RIGHT:
System.out.println("右");
break;
}
}
4.抽象类
4.1什么是抽象类
abstract修饰类，这个类就是抽象类。
4.2什么是抽象方法
abstract修饰方法，这个方法就是抽象方法。只有方法签名，不能写方法体。
4.3定义格式
修饰符 abstract class 类名{ 修饰符 abstract 返回值类型 方法名称(形参列表)； }
public abstract class A{
public abstract void test（）；
}4.4作用
被子类继承。如果父类知道子类一定要做这件事，但是每个子类做的不一样，父类可以声明抽象方法，交给子类重写来实现。这个类就是抽象类了。
4.5抽象类的注意事项
【1】抽象类中不一定要有抽象方法，有抽象方法的类必须是抽象类。
【2】类有的成员：成员变量、方法、构造器，抽象类都可以有。
【3】抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
【4】一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
【5】不能用abstract修饰变量、代码块、构造器。
4.6模板方法设计模式
父类知道每个子类都要做某个行为，但每个子类要做的情况不一样，父类就定义成抽象方法，交给子类去重写实现，我们设计这样的抽象类，就是为了更好的支持多态。
public abstract class ZwModel {
public void write(){
System.out.println("《我的区长爸爸》");
writeMain();
System.out.println("他真厉害！");
}
public abstract void writeMain();
}
public class MyZw extends ZwModel{
@Override
public void writeMain() {
System.out.println("我爸爸手眼通天哈哈哈");
}
}public class YouZw extends ZwModel{
@Override
public void writeMain() {
System.out.println("我好羡慕你爸爸");
}
}
public static void main(String[] args) {
MyZw myZw=new MyZw();
myZw.write();
System.out.println("===============================");
YouZw youZw=new YouZw();
youZw.write();
} 
5.接口
5.1接口是什么
使用interface关键字定义的一种结构， JDK 8之前，接口中只能定义成员变量和成员方法。
public interface Driver5.2接口的特点
【1】接口不能创建对象；接口是用来被类实现（implements）的，实现接口的类称为实现类。
【2】一个类可以实现一个或多个接口，实现类实现多个接口，必须重写完全部接口中的全部抽象方法，否则实现类需要定义成抽象类。
5.3接口与接口的关系
多继承
5.3.1什么意思
一个接口可以同时继承多个接口
5.3.2作用
规范合并，整合多个接口为同一个接口，便于子类实现。
5.3.3注意
实现子接口名的类必须实现后面所有接口中的所有抽象方法。
public interface Driver extends ha
//ha也为接口5.4继承抽象类的同时实现多个接口
5.4.1类和类的关系
单继承
5.4.2类和接口的关系
多实现
5.4.3语法
修饰符 class 实现类 extends 父类 implement 接口1，接口2....{}5.5使用接口的好处
【1】弥补了类单继承的不足，一个类在单继承的同时还可以实现多个接口。
【2】让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现（多态思想）。
5.6小案例
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
private String name;
private char sex;
private double score;
}
public interface ClassDataOp {
void All(Student[] students);
void avg(Student[] students);
}public class Op1 implements ClassDataOp{
@Override
public void All(Student[] students) {
for (int i = 0; i < students.length; i++) {
Student student = students[i];//获取每个学生
System.out.println(student.getName() + " " + student.getScore() + " " + student.getSex());
}
}
@Override
public void avg(Student[] students) {
double sum = 0;//定义求和变量
for (int i = 0; i < students.length; i++) {
Student student = students[i];//获取每个学生
sum += student.getScore();//求和
}
System.out.println("平均成绩：" + sum / students.length);
}
}public class Op2 implements ClassDataOp{
@Override
public void All(Student[] students) {
//定义统计男生人数的变量
int count = 0;
for (int i = 0; i < students.length; i++) {
Student student = students[i];//获取每个学生
System.out.println(student.getName() + " " + student.getScore() + " " + student.getSex());
if (student.getSex() == '男') {
count++;
}
}
System.out.println("男生人数：" + count);
System.out.println("女生人数：" + (students.length - count));
}
@Override
public void avg(Student[] students) {
double sum = 0;//定义求和变量
//定义最高分
double max = students[0].getScore();
//定义最低分
double min = students[0].getScore();
for (int i = 0; i < students.length; i++) {
Student student = students[i];//获取每个学生
sum += student.getScore();//求和
//求最大值
if (student.getScore() > max) {
max = student.getScore();
}
//求最小值
if (student.getScore() < min) {
min = student.getScore();
}
}
System.out.println("平均成绩：" + (sum-max-min) / (students.length-2));
}
} public static void main(String[] args) {
//1:创建5个学生对象
Student s1 = new Student("张三", '男',100);
Student s2 = new Student("李四", '女',80 );
Student s3 = new Student("王五", '男',90);
Student s4 = new Student("赵六", '女',70);
Student s5 = new Student("田七", '男',60);
Student[] student= {s1, s2, s3, s4, s5};
ClassDataOp op=new Op2();
op.All(student);
op.avg(student);
}5.7JDK8开始接口新增的方法
5.7.1默认方法
类似之前写的普通实例方法：必须用default修饰。默认会public修饰。需要用接口的实现类的对象来调用。
default void defaultMethod（）{
System.out.println（“接口中的默认方法”）;
}5.7.2静态方法
默认会public修饰，必须static修饰。接口的静态方法必须用本身的接口名来调用。
static void staticMethod（）{
System.out.println（“接口中的静态方法”）;
}5.7.3私有方法
必须使用private修饰，从JDK 1.9才开始有的。根据是否有static关键字修饰，私有方法可以分为非静态私有方法和静态私有方法。非静态私有方法只能在本类中被其他的默认方法或者私有方法访问。静态私有方法还能在本类的其他静态方法中访问。
private void privateMethod（）{
System.out.println（“接口中的私有方法”）;
}5.8使用接口的注意事项
【1】接口不能创建对象
【2】一个类实现多个接口，多个接口的规范不能冲突
【3】一个类实现多个接口，多个接口中有同样的静态方法不冲突。
【4】一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
【5】一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。
【6】一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。
标签：day07,System,接口,final,学习,println,javaSE,public,out From： https://blog.csdn.net/zhangnobill/article/details/140582815