JavaSE（基础篇-进阶篇day03）

基础篇：

Day7-02类与对象

Day7-03类与对象的补充

Day7-06this关键字

Day7-07构造方法

 即使我们没有显式地定义无参构造函数，系统也会默认提供一个无参构造函数

Day7-08分装介绍

Day7-09权限修饰符和封装案例 

private（下面的是同一个包下）:

(default)(默认权限)（下面的是不同一个包下）:

public（下面的是不同一个包下）:

Day7-11面向对象综合案例

这个要自己全程去看了

Day9-07--Day9-11学生管理系统

同上

进阶篇：

Day1-01static修饰成员的特点

特点一(特点看图里面写了)：

特点二和三（不用stu1.school了，直接用Student.school，特点三的意思是本来要先创造对象在调用school，但是现在可以先调用school再创造对象了）：

Day1-03static修饰成员方法-工具类-注意事项 

在静态方法中，只能访问静态成员(直接访问)

 如果想访问不是静态的：

Day1-04继承介绍和使用

继承最简单的理解：

继承的使用

实体类变量定义要私有，虽然这样子类不能继承，但是可以用get（），set（）（public公共的）

继承什么时候使用：

Day1-05继承中成员变量和成员方法的访问特点

 成员变量：

优先使用子类的

如果一定要用父类的，用super 

成员方法：

子父类中,出现了方法声明一模一样的方法(方法名,参数,返回值)
在创建子类对象,调用方法的时候,会优先使用子类的方法逻辑
这虽然是就近原则的现象,但其实是子类的方法,对父类的方法,进行了重写操作

上图运行效果：

Day1-06方法重写

方法重写：

方法重载（下面父类中的方法和子类中的方法虽然不在同一类当中，但是子类继承了父类，所以相当于在同一个类中，然后方法名一样，参数不一样，所以两个方法是方法重载）：

能够独立识别出,方法是不是重写的方法
- 注解:@Override,写上面看他包不包红

方法重写的使用场景：

还需要父类的方法

 不需要父类的方法

注意事项

● 父类中私有方法不能被重写

● 子类重写父类方法时,访问权限必须大于等于父类

Day1-07权限修饰符-java继承的特点

权限修饰符

下图中Fu在包a下，Zi类和测试类在包b下

 protected的不同包的子类的权限实现是要在Zi类里面，而不是直接在test类里面调用，因为test和fu类是不同包下的无关类，如果一定要用的话就像下面这样

支持单继承不支持多继承

能多层继承 

Day1-08继承中构造方法访问特点

不能被继承，因为构造方法要求和类的名字一样，Zi类中类名是Zi，fu的构造方法名字是Fu

除了0bject类,在所有构造方法的第一行代码,都默认隐藏了一句话 super();
通过这句代码,访问父类的空参数构造方法
这就是为什么会有两个"这是Fu类的空参构造方法"的原因

细节:Java当中所有的类,都直接或者间接的继承到了 Object 类，这就是为什么我A类什么方法都没写，但是他创建完对象，能a.出这么多方法，这是因为都在Object类里面有

写一个需求：

需求:

人类:(Person)
成员变量:姓名,年龄

老师类:

成员变量:姓名,年龄
成员方法:teach
- 姓名为张三,年龄为30岁的老师正在讲课

学生类:

成员变量:姓名,年龄,成绩
成员方法:study
- 姓名为李四,年龄为20岁,成绩为100分的学生,正在学习

Day1-10继承综合练习

案例要求：

可以接着父类的方法接着写，也可以像下面这样全部重写，这样实体类那里的work方法写什么都没关系了：

 

有关Java实体类中get、set方法和有参无参构造方法的个人见解。

1.有关Java实体类中get、set方法和有参无参构造方法的个人见解。

2.java实体类get/set方法，有参/无参，toString方法

3.Java类中构造方法、set/get方法、toString方法

Day1-11-this和super

关于访问构造方法：

 

这边不能只写super（），不然没办法调用上面的构造方法：

 而且两个不能同时写，两个都想争第一行：

Day1-12-fianal关键字

没有final的方法重写

有final的方法重写 

父类所有方法都不想被子类重写，就直接整个类final，不被子类继承

 

修饰变量：

基本数据类型

引用数据类型

final修饰成员变量注意事项：

 建议直接在定义的时候直接赋值，不要像下面一样在构造方法中赋值

Day2-01-package包和抽象类介绍

如果两个类名相同在不同的包下，想在test类下使用，一个导包使用，一个就要用全类名创建对象

抽象类

应用场景：

改成抽象方法后强制要求重写方法不然会报错

Day2-02-抽象类注意事项

1. 抽象类不能实例化
-如果抽象类允许创建对象,就可以调用内部没有方法体的抽象方法了

2. 抽象类存在构造方法
- 交给子类,通过super进行访问

 3. 抽象类中可以存在普通方法
- 可以让子类继承到继续使用

4. 抽象类的子类
1). 要么重写抽象类中的所有抽象方法

2). 要么是抽象类

但是抽象类不能实例化，这样就不能创建对象了听上去好像没用，但是看下面：

abstract关键字冲突

Day2-03-接口介绍以及定义和实现

接口:体现的思想就是声明[规则]

思路:如果发现一个类,所有的组成,都是抽象方法
- 没有成员变量
- 没有普通方法

这种类,我们通常会设计为Java中的接口,因为现在这个类存在的唯一价值,就只是声明规则了

接口的定义格式:

interface 接口名 {}

注意:接口不允许实例化

接口和类之间是实现关系,通过implements关键字来完成

class 类名 implements 接口名 {}

实现类(接口的子类):

1. 重写所有抽象方法

2. 将实现类变成抽象类(基本不用)

 

Day2-04-接口中的成员特点-类和接口之间的各种关系

接口的成员特点:

1. 成员变量:只能定义常量,因为系统会默认加入三个关键字
public static final(三个关键字没有前后顺序)

static(有的话就可以通过类名访问)

final (只能被赋值一次）

public（可以跨包访问）

 

2. 成员方法:只能是抽象方法,因为系统会默认加入两个关键字
public abstract(关于接口中的方法,JDK8 和 JDK9 中有一些新特性)

编写方法的时候直接像void method（）一样就好了，前面系统会自动加

3. 构造方法:没有

接口和类之间的各种关系:

1..类和类之间:继承关系,只支持单继承,不支持多继承,但是可以多层继承。

2.类和接口之间:

实现关系,可以单实现,也可以多实现

 可以多实现

也可以这样，不会有逻辑冲突，因为接口里面的方法都没有逻辑

甚至可以在继承一个类的同时,实现多个接口

相当于Zi类继承Fu类的时候已经把接口的A，B的show方法重写了

3. 接口和接口之间:继承关系,可以单维承,也可以多维承

接口C继承了接口A，B，所以实现类要重新3个抽象方法

 这样的话就只要重写一个方法了，不会有逻辑冲突因为接口里面的方法都没有逻辑

 Day2-05-抽象类和接口的对比

抽象类和接口的对比

抽象类的应用场景：

 接口的应用场景：

Day2-06-多态引入

前置代码：

OrderService：

 OrderServiceImpl：

  OverseasServiceImpl：

Test:

运行：

等于上面那个：

orderService 记得初始化，不然会像下面那样报错，因为如果输入的不是1或2，那么orderService 就没有被赋值了，也不能调用下面一堆方法了

 多态的理解：

保留问题

Day2-07-多态的前提-对象多态和行为多态

多态的前提:

有继承/实现关系（extends）
有方法重写(@Override)
有父类引用指向子类对象(Animal a1 =new Dog() 和Animal a2 =new Cat()，Animal a1父类，new Dog()和new Cat()是子类现象)

1. 对象多态

Animal a1 = new Dog();
Animal a2 = new Cat();

好处:方法的形参定义为父类类型,这个方法就可以接收到该父类的任意子类对象了

2. 行为多态

好处:同一个方法（eat方法）,具有多种不同表现形式,或形态的能力（输出不同）

 

Day2-08-多态的成员访问特点和好处

代码准备：

多态的成员访问特点:

1. 成员变量:

编译看左边(父类),运行看左边(父类)

Fu f =new Zi()   多态创建对象

f.num 调用成员变量

2. 成员方法:

编译看左边(父类),运行看右边(子类)

在编译的时候,会检查父类中有没有这个方法
没有:编译出错
有:编译通过,但是运行的时候,一定会执行子类的方法逻辑

运行看右边(子类)的原因:担心你调用的方法,在父类中是一个抽象方法

你调用的方法,在父类中是一个抽象方法：

Inter i =new InterImpl()是父类引用子类对象，所以是多态，然后接口中的method是抽象方法

多态创建对象,调用静态成员:

静态的成员,推荐类名进行调用
细节:静态的成员,可以使用对象名调用,但这是一种假象
- 生成字节码文件后,会自动将对象名调用,改成类名调用

代码准备：

测试结果：

成员方法不应该是编译看左边(父类),运行看右边(子类)，这个怎么是运行看父类？

答：右边那一半是字节码文件，左边看上去是用对象名调用print（），但是其实是用的类名调用，然后用谁的类调用那么输出就是谁的print。

回答上面的保留问题

1. 创建对象的时候,左右两边的类型可以不一致,是所有对象都可以这样创建吗?

只有父类引用指向子类对象或者接口的应用指向实现类对象才能这样创建

2.为什么调用的方法,是同一套方法,但是却有不同的表现形式呢?

因为多态创建完对象，调用成员方法的时候，编译看父类,运行看子类，给不同的子类对象，走的就是不同代码逻辑，所以就有不同的表现形式

多态的好处和弊端

好处：

弊端：

在子类写一个特有方法：

发现调用不了 

Day2-09-多态的转型和案例

转型

解决上面多态的弊端中调用不了子类中的特有方法（向下转型）：

但是也有弊端（输入1的时候，实际类型是国内订单对象，目标类型是国外订单对象）：

解决方法（加个if，用instanceof判断）：

 

案例：

 偷懒了一点，没写里面各种银行

Day3-01-JDK8和JDK9接口的新特性

JDK8版本接口特性:

1. 允许定义非抽象方法,需要加入default关键字

                         - 作用:解决接口的升级问题

代码准备：

想在Inter接口里面新增一个方法，但是不想让实现类重写                                                                

解决办法（在方法中加入default，这样实现类就不用重写也可以用method方法了）： 

 - 注意事项:

    1. public可以省略,但是default不能省略，虽然 public可以省略，但是他的权限还是public不是默认权限

    2. 默认方法,实现类是允许重写的,但是需要去掉default关                                                                   键字（这里说去掉default关键字说的是重写的方法没有default关键字）

这里面Inter.super.method();直接删掉就好了，因为要对接口的method方法重写至于Inter.super.method();的作用下面有介绍

Inter.super.method();的作用：

没有 Inter.super.method();

   

3. 如果实现了多个接口,多个接口中存在相同的默认方法,                                                                   实现类必须重写默认方法

 没有重写，报错

重写(也可以只选择A或者Inter的method方法):

2. 允许定义静态方法

- 理解:既然接口已经允许方法带有方法体了,干脆也放开静态方法,可以类名调用

- 注意事项:

1. public可以省略,但是static不能省略

2. 接口中的静态方法,只允许接口名进行调用,不允许实现类通过对象调用

通过对象调用报错

接口名进行调用 

JDK9接口特性:

接口中允许定义私有方法（提升复用性，减少冗余代码）

代码准备（接口中定义私有方法的应用场景）：

接口中两个方法都有一个日志记录的部分，重复了，写两遍麻烦

 可以这么写：

而且log方法只是服务start和end方法的， 不希望别人调用，私有化他（接口中的私有方法不能带default）

还可以是静态的私有方法（当start和end方法是静态的时候应用，静态只能访问静态）：

Day3-02-代码块

代码块:使用 {}括起来的代码被称为代码块

分类:

1. 局部代码块（很少用）

位置:方法中的一对大括号
作用:限定变量的生命周期,提早的释放内益

2. 构造代码块（很少用）

位置:类中方法外的一对大括号
特点:在创建对象,执行构造方法的时候,就会执行构造代码块(优先于构造方法执行)

优先于构造方法执行的原因：

右边是左边的字节码文件：

作用:将多个构造方法中,重复的代码,抽取到构造代码块中,从而提升代码的复用性 

用了构造代码块之前：

用了构造代码块之后：

3. 静态代码块

位置:类中方法外的一对大括号,需要加入static关键字

特点:随着类的加载而执行,因为类只加载一次,所以也就只执行一次

作用:对数据进行初始化

虽然可以在外面定义的时候直接赋值，但是以后要是遇到是一个对象类型 ，而且对象创建很复杂，就要用到静态代码块

 比如：

Day3-03-内部类-成员内部类（了解就行，不常用）

内部类:在类中定义的类

创建对象格式:外部类名.内部类名 对象名= new 外部类对象().new 内部类对象();

成员访问细节:

1. 内部类中,访问外部类成员:直接访问,包括私有

2. 外部类中,访问内部类成员:需要创建对象访问

 当外部类成员变量和内部类的成员变量重名了，在成员内部类中该如何访问所在的外部类对象：

内部类的使用场景：

可以把发动机单独拎出来

像这样：虽然封装性更好，但是用起来麻烦，所以基本不怎么用

内部类分类（前三个内部类基本不怎么用，最后一个重要）：

Day3-04-内部类-静态内部类-局部内部类（基本不用）

静态内部类:static 修饰的成员内部类

创建对象格式:外部类名.内部类名 对象名=new 外部类名.内部类对象();

也可以这样访问：

注意事项:静态只能访问静态

 一定要访问的话，像下面一样：

 局部内部类:放在方法、代码块、构造器等执行体中：（不用这玩意）

他没有格式，因为在main里面调用不到B类：

要用只能这么用： 

 Day3-05-匿名内部类

代码准备： 

想要调用userInter方法（形参是接口类型）（接口不能实例化，不能创建对象）

传入接口的实现类对象（多态） 

上面太麻烦了，用匿名内部类只需要一步（蓝色部分，相当于把下面的接口实例化搬到了这里）：

匿名内部类:

概述:匿名内部类本质上是一个特殊的局部内部类(定义在方法内部)
前提:需要存在一个接口或类
格式:

new 类名\接口名(){

}

new类名(){} :代表继承这个类
new 接口名(){}:代表实现这个接口

结论：可以让代码变得更加简洁，在定义的时候就对其进行实例化操作

单独写实现类和匿名内部类的选择：

现在接口里面有好多方法：

你不可能在匿名实现类里面重写所有方法（阅读性不高，臃肿）：

 

所以接口里面方法多就单独写实现类（公正，维护起来方便）

如果接口里面方法少就写匿名内部类

 Day3-06-Lambda表达式介绍

Lambda表达式:JDK8开始后的一种新语法形式

作用:简化匿名内部类的代码写法。
格式:()->{}

():匿名内部类被重写方法的形参列表
{}:被重写方法的方法体代码

---------上面是匿名内部类，下面是Lambda表达式

代码准备（接口中有2个抽象方法）：

发现Lambda表达式报错了： 

Lambda表达式,只允许操作函数式编程接口:有,且仅有一个抽象方法的接口 ，所以不是所有匿名内部类都可以用Lambda表达式

检验是不是函数式编程接口的注解：

 Day3-07-Lambda表达式省略规则

Lambda表达式的省略写法

● 参数类型可以省略不写。

原来（里面有参数）：

省略参数类型： 

● 如果只有一个参数,参数类型可以省略,同时()也可以省略，当（）里面没有参数的时候，（）不能省略。

 原来（里面有参数）：

 省略参数类型的同时把（）也省略了：

原来（里面没有参数）：

 不能省略（）

● 如果Lambda表达式的方法体代码只有一行代码

可以省略大括号不写,同时要省略分号

原来（里面有参数）：

省略大括号不写,同时要省略分号：

此时,如果这行代码是return语句,必须省略return不写,同时也必须省略“;”不写

 原来（没有参数但是有返回值）：

 省略大括号，分号，return（输出不同是因为产生的随机数）

额外的知识：

返回随机数（1-100）： 

1. return new Random().nextInt( bound: 100) + 1;

2.    Random r = new Random();

       int num = r.nextInt(100) + 1;
       return num;

 Day3-08-Lambda表达式和匿名内部类的区别-构造窗体

Lambda表达式和匿名内部类的区别

使用限制不同

● 匿名内部类:可以操作类,接口
●Lambda表达式:只能操作函数式接口

实现原理不同

● 匿名内部类:编译之后,产生一个单独的.class字节码文件
● Lambda表达式:编译之后,没有一个单独的.class字节码文件

代码准备和运行：

   

A.class  接口A的字节码文件

LambdaDemo3$1.class  匿名内部类的字节码文件（1代表编号，如果再来一个匿名内部类，就接着往下）

LambdaDemo3.class 测试类的字节码文件

但是Lambda表达式没有字节码文件

 

构建窗体：

导包时后面的星号介绍：

import javax. swing. *;

import java.util .*;

代表把该包下所有的类都导过来了

Scanner Random ArrayList<>这三个类都是util包下的

构建窗体，设置可见，设置大小（单位是像素）：

为什么要先关闭掉程序在重新运行（窗体已经关了）

修改窗体的关闭模式：

 setDefaultCloseOperation    默认情况下,该值被设置为HIDE_ON_CLOSE。

关于里面的int类型 

 最后里面要写的（关闭窗体就直接关闭程序）

设置标题：

 最好把窗体可见放在最后

Day3-09-窗体添加按钮

创建一个空白按钮：

运行结果（按钮撑满了整个屏幕） 

 创建一个带文本的按钮：

注意:

窗体中存在默认布局方式

可通过

setLayout(null);取消默认布局

运行结果 (啥也没了，因为你把默认布局取消了，但是没有规定，所以不知道放哪)

注意:如果取消了窗体的默认布局,就需要手动指定组件的摆放位置了 

手动指定窗体的布局(x,y是坐标)：

Day3-10-JLabel展示文本和图片

JLabel展示文本

JLabel展示文本和图片 :

代码：

运行： 

在加一个图片一样的大小一样的位置：

发现是在之前加的图片下面：

注意:如果多个组件摆放在同一个位置,后添加的组件,会被压在底部。

如果图片发现不完整，有可能是你设置的图片的大小比原图片小：

Day3-11-事件监听

ActionListener:动作监听器 (鼠标点击,空格按下)

代码准备：

 鼠标点击/空格按下

KeyListener:键盘监听器 

代码准备（没有按钮，所以时事件源是窗体）：

 对重写的方法的补充：

 运行后点击键盘的任意值都会出现：
键盘按下了。。。。

键盘松开了。。。。

 运行后点击键盘的任意值都会出现对应的数字（最后4个是左上右下按钮）

所以可以根据输入的数字判断输入的按钮：

运行结果： 

至于重写的这个方法只能监听到字母和数字之类的，其他的特殊按钮监听不到，比如：fn ctrl esc 上下左右

@Override
public void keyTyped(KeyEvent e) {
// fn ctrl esc 上下左右

}

焦点:程序的注意力集中在了某一个组件上

注意:按钮组件比较特殊,在创建好之后,程序的焦点,默认就停留在按钮组件上面
- 但按钮组件,其实不需要占用程序的焦点
- 可以通过 setFocusable(false);取消焦点

代码准备（一个动作监听和一个键盘监听，主要就是点空格是输出动作监听的还是键盘监听的？）：

 输出动作监听的：

 解决办法（加一个 setFocusable(false);，加前那个按钮文字有框框框住，说明是焦点，加后就没有，说明失去焦点了）：

 输出（按空格输出键盘按下了，而后用鼠标点还是输出我被点了）：

Day3-12-适配器设计模式

设计模式说白了就是套路（共23种）

适配器设计模式:解决接口与接口实现类之间的矛盾问题:

 

问题来源（匿名内部类中只有一个重写方法对我有用，其他的不想要，但是不能不写）： 

 

 

 用另外一个代码材料来举例：

同样的问题鲁智深不打坐念经撞钟，只习武，所以蓝色部分没用，但是还不能删，因为删了不符合语法（必须重写所有方法）

 

解决方法/ 实现步骤

1. 编写一个 xxxAdapter 类,实现对应接口
2. 重写内部所有抽象方法,但方法都是空实现

3. 让自己的类去继承适配器类,重写自己需要的方法即可

4. 为了避免其他类创建适配器类的对象,使用abstract 进行修饰

如果不加abstract，那么就可以创建对象调用里面没有逻辑的方法（没意义）：

 

 

回到上面那个问题的解决方法（java自带的KeyListener的适配器类KeyAdapter）：

运行结果：

 

 Day3-12-模板设计模式

代码准备：

想别人写正文，其他的调用这个write方法写一篇作文 

运行：

 

为了防止有人重写write方法：

 加一个final

 这样就不行了：