10_接口丶内部类丶权限修饰符
Day10笔记
课程内容
一、接口java
二、内部类express
三、Eclipse数组
四、包eclipse
五、权限修饰符ide
接口
概述
一、广义的接口：一切定义规则的都是接口，一切用于二者交互的方式都是接口工具
二、Java中的接口：用于定义方法名称、方法功能的规则学习
三、好处：开发工具
将【方法的实现】和【方法的使用】分离开，二者的耦合性就下降了字体
提升了开发效率网站
接口的特色
一、接口使用interface关键字声明
interface 接口名称 {
方法的声明;
}
编译完成以后，仍然是一个.class的字节码文件
二、接口中的内容：
能够声明抽象方法：只能有方法的声明，不能有方法的实现
做用：规定方法的名称、功能、返回值、参数
三、接口的实现类：
实现：定义一个类，将接口中的抽象方法全都实现，这个过程，就称为“实现接口”
关键字：implements，格式：
class 实现类类名 implements 接口名 {
对接口中的全部抽象方法进行重写（实现）
}
四、接口的实例化：
结论：接口不能建立对象
解决：经过实现类来实例化，定义实现类，实现接口中的方法，实现类建立对象并调用 方法
说明：可使用接口类型的引用，指向实现类对象（接口的多态）
五、接口的实现类的前途：
一、若是实现类中没有重写完接口中的所有方法，那么该类型仍是一个抽象类，不能建立对象；
二、若是实现类重写了接口中全部的抽象方法，那么该类型就能够变成一个具体类，能够建立对象。
代码示例
class Demo01_接口特色 {
public static void main(String[] args) {
MyImpl mi = new MyImpl();
mi.test1();
mi.test2();
//接口的引用，指向实现类的对象：接口的多态
MyInter m = new MyImpl();
m.test1();
m.test2();
}
}
interface MyInter {
public abstract void test1();
public abstract void test2();
}
class MyImpl implements MyInter {
@Override
public void test1() {
System.out.println("test1");
}
@Override
public void test2() {
System.out.println("test2");
}
}
接口中成员的特色
一、成员变量：
不能定义变量，只能定义常量
默认会在成员变量前面加上public static final关键字，建议手动加上
二、构造方法：
没有
一、接口不须要建立对象，因此不须要有构造方法
二、接口的实现类的构造方法，不会访问所实现的接口的构造方法，由于实现类有本身的父类，访问的是父类的构造方法
三、成员方法：
只能是抽象方法，不能是非抽象方法
默认会在成员方法前面加上public abstract，建议手动加上
代码示例
class Demo02_接口中成员的特色 {
public static void main(String[] args) {
//说明a前面默认添加了一个static
System.out.println(MyInter.a);
//说明a前面默认添加了一个final，变成了常量
//MyInter.a = 20;
}
}
interface MyInter {
public static final int a = 10;
//void test1();
}
class MyImpl extends Object implements MyInter {
}
类与类、类与接口、接口与接口的关系
一、类与类：
继承的关系，关键字extends
支持单继承、不支持多继承、支持多层继承
二、类与接口：
实现的关系，关键字implements
能够单实现，也能够多实现（一个实现类，能够同时实现多个接口：一个儿子能够有多个干爹），没有多层实现（实现类一旦实现一个接口，就变成了类，不能再被实现了）
【多实现的格式】：
class 实现类类名 implements 接口1, 接口2...{
重写全部接口中的全部抽象方法
}
一个类，能够在继承一个父类的同时，实现多个接口
【实现格式】：
class 类名 extends 父类类名 implements 接口1, 接口2... {
重写父类和全部接口中的全部抽象方法
}
三、接口与接口
继承关系，关键字extends
支持单继承，支持多继承，支持多层继承
【多继承】格式：
interface Inter1 extends Inter2, Inter3 {
继承了Inter2和Inter3的全部抽象方法
}
四、接口和抽象类的比较：
一、语法上：接口能够多实现，抽象类只能单继承
二、设计：
抽象类：用于定义事物自己具备的功能和特征，定义的是最原始的固有的描述
接口：用于定义扩展出来的功能和方法，定义的通常是后天学习训练而来的能力
代码示例1
class Demo03_接口与类的关系 {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
interface A {
public abstract void testA();
}
interface B {
public abstract void testB();
}
abstract class C {
public void testC1() {
System.out.println("c1");
}
public abstract void testC2();
}
class D extends C implements A, B {
@Override
public void testC2() {
System.out.println("c2");
}
@Override
public void testA() {
System.out.println("a");
}
@Override
public void testB() {
System.out.println("b");
}
}
代码示例2
class Demo04_接口与接口的关系 {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
interface Inter1 {
public abstract void test1();
}
interface Inter2 {
public abstract void test1();
}
interface Inter3 extends Inter1, Inter2 {
//随意从Inter1或者Inter2中继承一个就行
}
USB接口案例
代码示例1
class Demo05_USB接口案例 {
public static void main(String[] args) {
Computer c = new Computer();
Mouse m = new Mouse();
c.开机();
c.useMouse(m);
c.关机();
}
}
class Computer {
public void 开机() {
System.out.println("电脑启动");
}
public void useMouse(Mouse m) {
m.use();
}
public void 关机() {
System.out.println("关闭电源");
}
}
class Mouse {
public void use() {
System.out.println("鼠标移动");
}
}
代码示例2
class Demo06_USB接口案例改进 {
public static void main(String[] args) {
Computer c = new Computer();
Mouse m = new Mouse();
KeyBoard kb = new KeyBoard();
c.开机();
c.useUSB(m);
c.useUSB(kb);
c.关机();
}
}
class Computer {
public void 开机() {
System.out.println("电脑启动");
}
public void useUSB(USB usb) {
usb.use();
}
public void 关机() {
System.out.println("关闭电源");
}
}
interface USB {
public abstract void use();
}
class Mouse implements USB {
public void use() {
System.out.println("鼠标移动");
}
}
class KeyBoard implements USB {
public void use() {
System.out.println("键盘录入");
}
}
内部类
概述
一、定义在内部的类，就是内部类
二、根据内部类位置的不一样：
成员内部类：类中方法外
普通的成员内部类
私有的成员内部类
静态的成员内部类
局部内部类：方法中
三、表现形式的不一样：
有名字的内部类
匿名内部类【经常使用】
普通的成员内部类
一、定义位置：
类中方法外
二、定义格式：
直接使用class定义内部类便可
三、内部类特色：
一、能够访问外部类的成员，包括私有成员（由于内部类也是外部类的成员之一）
二、外部类或者其余类访问内部类的成员，必须先建立内部类对象
四、建立对象的格式：
外部类类名.内部类类名 内部类对象名 = new 外部类类名().new 内部类类名();
内部类对象名.内部类的成员
代码示例
class Demo07_普通的成员内部类 {
public static void main(String[] args) {
Body.Heart bh = new Body().new Heart();
bh.speak();
}
}
class Body {
private double height = 149.0;
class Heart {
int beats = 90;
public void speak() {
System.out.println(height + "..." + beats + "...心脏扑通扑通的跳");
}
}
public void test() {
Heart h = new Heart();
System.out.println(h.beats);
}
}
私有的成员内部类
一、在普通成员内部类的基础上，加一个private关键字修饰这个内部类
二、访问方式：
一、其余类，不能直接访问私有的成员内部类
二、在外部类中，定义一个公有的访问方式，建立私有成员内部类对象，调用对象方法，未来可让外界间接地访问私有成员内部类，而且调用私有成员内部类方法
代码示例
class Demo08_私有成员内部类 {
public static void main(String[] args) {
Body b = new Body();
b.useShen();
}
}
class Body {
private double height = 149.0;
private class Shen {
int age = 40;
public void go() {
System.out.println(height + "..." + age + "...该走心得时候别找我！！");
}
}
public void useShen() {
Shen s = new Shen();
s.go();
}
}
静态的成员内部类
一、在普通成员内部类的基础上，加一个static关键字修饰这个内部类
二、在类中的静态成员，访问的时候不须要建立该静态成员所在类的对象，能够直接经过类名访问；因此静态成员内部类也不须要建立外部类对象，就能够直接访问；可是静态成员内部类中的非静态成员，须要先建立静态内部类对象以后，才能访问。
三、一个类是否须要建立对象，不取决于该类是否静态，而是取决于你要访问的是该类的静态成员仍是非静态成员。
四、建立静态内部类对象的格式：
外部类类名.内部类类名 内部类对象名 = new 外部类类名.内部类类名();
代码示例
class Demo09_静态的成员内部类 {
public static void main(String[] args) {
Body.Gan bg = new Body.Gan();
bg.speak();
}
}
class Body {
private static double height = 149.0;
static class Gan {
String color = "black";
public void speak() {
System.out.println(height + "..." + color + "...求你了别喝了受不了了");
}
}
}
局部内部类
一、定义在方法中的内部类
二、定义在方法中的任何内容（不管是局部变量、仍是局部内部类），在方法以外，都不能直接访问
三、只能在方法中，建立局部内部类对象，调用内部类对象的方法。外界调用内部类所在的方法，间接地访问方法中的内部类
代码示例
class Demo10_局部内部类 {
public static void main(String[] args) {
test();
}
public static void test() {
String need = "继续吃";
class Wei {
int size = 666;
public void speak() {
System.out.println(need + "..." + size + "...你吃不是由于我饿，是由于嘴巴寂寞");
}
}
Wei w = new Wei();
w.speak();
}
}
匿名内部类
一、没有名字的内部类
二、定义匿名内部类的前提：
一、有一个父类
二、或者实现了某一个接口
三、定义一个匿名内部类对象的格式：
new 父类类型或者接口类型() {
重写父类中的或者接口中的方法;
}
四、本质：
建立了一个接口的实现类对象
或者是一个父类的子类对象
说明：更多强调的是对象和某个接口或者父类的关系，而不是对象所属类的名称
代码示例
class Demo11_匿名内部类 {
public static void main(String[] args) {
IPlayImpl ip = new IPlayImpl();
ip.playGame();
new IPlay() {
@Override
public void playGame() {
System.out.println("wanyouxi");
}
}.playGame();
IPlay i = new IPlay() {
@Override
public void playGame() {
System.out.println("玩youxi");
}
};
i.playGame();
}
}
class IPlayImpl implements IPlay {
@Override
public void playGame() {
System.out.println("玩游戏");
}
}
interface IPlay {
public abstract void playGame();
}
Eclipse
概述
一、开发工具：
记事本
增强型的记事本（EditPlus）
集成开发环境（IDE：Integrated Development Environment）
二、继承开发环境：
Eclipse：日食，免费，开源，可扩展
MyEclipse：收费
Idea：收费
Eclipse的下载
二、Downloads----最新版本-----download packages//下载绿色版本的压缩包
三、选择 企业级开发的版本，Eclipse IDE for Enterprise Java Developers
四、选择下载源：选择中国的便可
Eclipse的安装
因为下载的是绿色版本的安装包，直接加压缩便可
看到了eclipse.exe就说明解压成功了
Eclipse的简单使用
一、双击eclipse.exe工具，看到以下提示框：
说明：一、若是没有看到这个界面，那说明没有把jdk安装好、或者path环境变量没有配置好；二、Workspace：工做空间，用于存储一个一个的工程的地方，说白了，就是存储代码的地方。
二、点击launch，开始，看到欢迎界面，关闭欢迎界面，看到开发的主界面：
三、在工程的资源管理器中，鼠标右键，选择new，选择other，以下界面：
四、选择java Project，以下界面：
五、添加工程名称，点击finish，以下界面：
说明：表示要作打开java工程，就须要切换到java工程经常使用的小窗口组合上去
六、点击OpenPerspective，在左侧的工程中，选择src，右键，选择new，选择class，以下：
七、填写类名、包名，勾上主方法，点击finish
八、编辑代码，无需编译（自动编译），点击绿色按钮来运行
View和Perspective
一、View：在eclipse中运行的一个一个的小窗口，每一个小窗口都有本身的特殊功能
Package Explorer：包资源管理器，用于查看整个工做空间中的全部工程
代码编辑的view：代码编辑的做用
Console：用于显示运行结果的view（控制台）
Outline：大纲view，显示当前类型中的全部属性、方法、内部类等
二、有关view的一个操做：
本身操做显示哪些view
Window----show view----选择本身须要的view便可
三、Perspective：
一、作不一样类型的开发，须要使用到不一样的view组合
二、不一样的view组合就称为不一样的Perspective
三、常常作的开发须要使用哪些view，已经比较固定了，因此eclipse给咱们提供了经常使用的Perspective
四、经常使用的Perspective：
Java Perspective：用于作基础的java开发，包括了package explorer、console、outline、代码编辑view
JavaEE Perspective：用于作开发网站的java开发，包括了Project explorer、Mark、Server、Data Source Explorer、outline等view
Debug Perspective：用于作程序的调试，能够实现程序的单步运行，包括了debug、breakpoints、variables、expressions等view
五、有关Perspective的操做：
一、窗口乱了，能够以下操做：
Window----perspective----reset Perspective
二、能够自定义本身须要的Perspective:
Window----Perspective----save Perspective as：新建本身经常使用的perspective
Eclipse的经常使用配置
一、配置字体：
使用ctrl + 放大字体
使用ctrl - 缩小字体
二、去掉不须要的注释：
三、去掉悬浮提示：
说明：须要看悬浮提示的时候使用键盘F2
Eclipse的内容辅助键
一、alt + /：自动生成代码，代码格式记忆不清楚时，使用这个来作一些提示：
二、举例：
Main + alt + /：生成主方法
Syso + alt + /：生成输出语句
自动生成类名、对象名、提示构造方法
遍历数组：找到最近的一个数组遍历
Eclipse的经常使用快捷键
一、ctrl + n：新建，新建文件、新建类、新建包、新建工程
二、Ctrl + shift + f：格式化代码
三、Ctrl + shift + o：删除不须要的导包语句，补充须要的导包语句
四、Ctrl + /：给选中的代码进行单行注释；给选中的代码去掉单行注释
五、Ctrl + shift + /：给选中的代码进行一个多行注释
六、Ctrl + shift + \：给选中的代码去掉多行注释
七、Alt + ↑：将选中的代码向上移动一行
八、Ctrl + alt + ↓：将选中的代码向下复制一行
九、Ctrl + d：删除选中的行，连换行符也一块儿删掉
十、Alt + shift + r：给变量重命名（全部该变量一块儿更名字）
十一、F2：修改类名，全部引用该类型的地方都会发生改变
基本的编辑快捷键：
Ctrl ：A、C、X、V、Z、Y
快速生成一个自定义类的方法
一、自定义类中的各类方法，可使用快捷键生成
二、类中的成员变量，须要本身定义，成员变量的内容没法预测；
三、Alt + shift + s：操做有关源代码的快捷键
四、C：从父类生成各类构造方法（通常是空参构造）
五、O：根据本身的字段生成对应的构造方法
六、R：生成字段对应的get、set方法
七、S：生成字段对应的toString方法
- 1. JDBC丶链接池丶DBUtils丶事务
- 2. Servlet丶ServletContext丶Response丶Request
- 3. 修饰符中的状态修饰符、权限修饰符、抽象修饰符、接口修饰符
- 4. 文件操做---File丶FileInputStream丶BufferedInputStream丶InputStreamReader丶FileReader丶BufferedReader
- 5. （内部类，权限修饰符，多态，抽象类）2020.10.22
- 6. 权限修饰符
- 7. JSP丶EL丶JSTL
- 8. 11 final 、权限修饰符、内部类、匿名内部类（重点）
- 9. final关键字，权限修饰符、内部类
- 10. Java内部类、修饰符
- 更多相关文章...
- • Scala 访问修饰符 - Scala教程
- • Kotlin 接口 - Kotlin 教程
- • 算法总结-滑动窗口
- • Kotlin学习（二）基本类型
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. JDBC丶链接池丶DBUtils丶事务
- 2. Servlet丶ServletContext丶Response丶Request
- 3. 修饰符中的状态修饰符、权限修饰符、抽象修饰符、接口修饰符
- 4. 文件操做---File丶FileInputStream丶BufferedInputStream丶InputStreamReader丶FileReader丶BufferedReader
- 5. （内部类，权限修饰符，多态，抽象类）2020.10.22
- 6. 权限修饰符
- 7. JSP丶EL丶JSTL
- 8. 11 final 、权限修饰符、内部类、匿名内部类（重点）
- 9. final关键字，权限修饰符、内部类
- 10. Java内部类、修饰符