Day10笔记
课程内容
1、接口
2、内部类
3、Eclipse
4、包
5、权限修饰符
接口
概述
1、广义的接口：一切定义规则的都是接口，一切用于两者交互的方式都是接口
2、Java中的接口：用于定义方法名称、方法功能的规则
3、好处：
将【方法的实现】和【方法的使用】分离开，两者的耦合性就降低了
提高了开发效率
接口的特点
1、接口使用interface关键字声明
interface 接口名称 {
方法的声明;
}
编译完成之后，仍然是一个.class的字节码文件
2、接口中的内容：
可以声明抽象方法：只能有方法的声明，不能有方法的实现
作用：规定方法的名称、功能、返回值、参数
3、接口的实现类：
实现：定义一个类，将接口中的抽象方法全都实现，这个过程，就称为“实现接口”
关键字：implements，格式：
class 实现类类名 implements 接口名 {
对接口中的所有抽象方法进行重写（实现）
}
4、接口的实例化：
结论：接口不能创建对象
解决：通过实现类来实例化，定义实现类，实现接口中的方法，实现类创建对象并调用 方法
说明：可以使用接口类型的引用，指向实现类对象（接口的多态）
5、接口的实现类的前途：
1、如果实现类中没有重写完接口中的全部方法，那么该类型还是一个抽象类，不能创建对象；
2、如果实现类重写了接口中所有的抽象方法，那么该类型就可以变成一个具体类，可以创建对象。
代码示例
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");
}
}
接口中成员的特点
1、成员变量：
不能定义变量，只能定义常量
默认会在成员变量前面加上public static final关键字，建议手动加上
2、构造方法：
没有
1、接口不需要创建对象，所以不需要有构造方法
2、接口的实现类的构造方法，不会访问所实现的接口的构造方法，因为实现类有自己的父类，访问的是父类的构造方法
3、成员方法：
只能是抽象方法，不能是非抽象方法
默认会在成员方法前面加上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 {
}
类与类、类与接口、接口与接口的关系
1、类与类：
继承的关系，关键字extends
支持单继承、不支持多继承、支持多层继承
2、类与接口：
实现的关系，关键字implements
可以单实现，也可以多实现（一个实现类，可以同时实现多个接口：一个儿子可以有多个干爹），没有多层实现（实现类一旦实现一个接口，就变成了类，不能再被实现了）
【多实现的格式】：
class 实现类类名 implements 接口1, 接口2...{
重写所有接口中的所有抽象方法
}
一个类，可以在继承一个父类的同时，实现多个接口
【实现格式】：
class 类名 extends 父类类名 implements 接口1, 接口2... {
重写父类和所有接口中的所有抽象方法
}
3、接口与接口
继承关系，关键字extends
支持单继承，支持多继承，支持多层继承
【多继承】格式：
interface Inter1 extends Inter2, Inter3 {
继承了Inter2和Inter3的所有抽象方法
}
4、接口和抽象类的比较：
1、语法上：接口可以多实现，抽象类只能单继承
2、设计：
抽象类：用于定义事物本身具有的功能和特征，定义的是最原始的固有的描述
接口：用于定义扩展出来的功能和方法，定义的一般是后天学习训练而来的能力
代码示例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("键盘录入");
}
}
内部类
概述
1、定义在内部的类，就是内部类
2、根据内部类位置的不同：
成员内部类：类中方法外
普通的成员内部类
私有的成员内部类
静态的成员内部类
局部内部类：方法中
3、表现形式的不同：
有名字的内部类
匿名内部类【常用】
普通的成员内部类
1、定义位置：
类中方法外
2、定义格式：
直接使用class定义内部类即可
3、内部类特点：
1、可以访问外部类的成员，包括私有成员（因为内部类也是外部类的成员之一）
2、外部类或者其他类访问内部类的成员，必须先创建内部类对象
4、创建对象的格式：
外部类类名.内部类类名 内部类对象名 = 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);
}
}
私有的成员内部类
1、在普通成员内部类的基础上，加一个private关键字修饰这个内部类
2、访问方式：
1、其他类，不能直接访问私有的成员内部类
2、在外部类中，定义一个公有的访问方式，创建私有成员内部类对象，调用对象方法，将来可以让外界间接地访问私有成员内部类，并且调用私有成员内部类方法
代码示例
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();
}
}
静态的成员内部类
1、在普通成员内部类的基础上，加一个static关键字修饰这个内部类
2、在类中的静态成员，访问的时候不需要创建该静态成员所在类的对象，可以直接通过类名访问；所以静态成员内部类也不需要创建外部类对象，就可以直接访问；但是静态成员内部类中的非静态成员，需要先创建静态内部类对象之后，才能访问。
3、一个类是否需要创建对象，不取决于该类是否静态，而是取决于你要访问的是该类的静态成员还是非静态成员。
4、创建静态内部类对象的格式：
外部类类名.内部类类名 内部类对象名 = 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 + "...求你了别喝了受不了了");
}
}
}
局部内部类
1、定义在方法中的内部类
2、定义在方法中的任何内容（无论是局部变量、还是局部内部类），在方法之外，都不能直接访问
3、只能在方法中，创建局部内部类对象，调用内部类对象的方法。外界调用内部类所在的方法，间接地访问方法中的内部类
代码示例
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();
}
}
匿名内部类
1、没有名字的内部类
2、定义匿名内部类的前提：
1、有一个父类
2、或者实现了某一个接口
3、定义一个匿名内部类对象的格式：
new 父类类型或者接口类型() {
重写父类中的或者接口中的方法;
}
4、本质：
创建了一个接口的实现类对象
或者是一个父类的子类对象
说明：更多强调的是对象和某个接口或者父类的关系，而不是对象所属类的名称
代码示例
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
概述
1、开发工具：
记事本
加强型的记事本（EditPlus）
集成开发环境（IDE：Integrated Development Environment）
2、继承开发环境：
Eclipse：日食，免费，开源，可扩展
MyEclipse：收费
Idea：收费
Eclipse的下载
2、Downloads----最新版本-----download packages//下载绿色版本的压缩包
3、选择 企业级开发的版本，Eclipse IDE for Enterprise Java Developers
4、选择下载源：选择中国的即可
Eclipse的安装
由于下载的是绿色版本的安装包，直接加压缩即可
看到了eclipse.exe就说明解压成功了
Eclipse的简单使用
1、双击eclipse.exe工具，看到如下提示框：
说明：1、如果没有看到这个界面，那说明没有把jdk安装好、或者path环境变量没有配置好；2、Workspace：工作空间，用于存储一个一个的工程的地方，说白了，就是存储代码的地方。
2、点击launch，开始，看到欢迎界面，关闭欢迎界面，看到开发的主界面：
3、在工程的资源管理器中，鼠标右键，选择new，选择other，如下界面：
4、选择java Project，如下界面：
5、添加工程名称，点击finish，如下界面：
说明：表示要做打开java工程，就需要切换到java工程常用的小窗口组合上去
6、点击OpenPerspective，在左侧的工程中，选择src，右键，选择new，选择class，如下：
7、填写类名、包名，勾上主方法，点击finish
8、编辑代码，无需编译（自动编译），点击绿色按钮来运行
View和Perspective
1、View：在eclipse中运行的一个一个的小窗口，每个小窗口都有自己的特殊功能
Package Explorer：包资源管理器，用于查看整个工作空间中的所有工程
代码编辑的view：代码编辑的作用
Console：用于显示运行结果的view（控制台）
Outline：大纲view，显示当前类型中的所有属性、方法、内部类等
2、有关view的一个操作：
自己操作显示哪些view
Window----show view----选择自己需要的view即可
3、Perspective：
1、做不同类型的开发，需要使用到不同的view组合
2、不同的view组合就称为不同的Perspective
3、经常做的开发需要使用哪些view，已经比较固定了，所以eclipse给我们提供了常用的Perspective
4、常用的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
5、有关Perspective的操作：
1、窗口乱了，可以如下操作：
Window----perspective----reset Perspective
2、可以自定义自己需要的Perspective:
Window----Perspective----save Perspective as：新建自己常用的perspective
Eclipse的常用配置
1、配置字体：
使用ctrl + 放大字体
使用ctrl - 缩小字体
2、去掉不需要的注释：
3、去掉悬浮提示：
说明：需要看悬浮提示的时候使用键盘F2
Eclipse的内容辅助键
1、alt + /：自动生成代码，代码格式记忆不清楚时，使用这个来做一些提示：
2、举例：
Main + alt + /：生成主方法
Syso + alt + /：生成输出语句
自动生成类名、对象名、提示构造方法
遍历数组：找到最近的一个数组遍历
Eclipse的常用快捷键
1、ctrl + n：新建，新建文件、新建类、新建包、新建工程
2、Ctrl + shift + f：格式化代码
3、Ctrl + shift + o：删除不需要的导包语句，补充需要的导包语句
4、Ctrl + /：给选中的代码进行单行注释；给选中的代码去掉单行注释
5、Ctrl + shift + /：给选中的代码进行一个多行注释
6、Ctrl + shift + ：给选中的代码去掉多行注释
7、Alt + ↑：将选中的代码向上移动一行
8、Ctrl + alt + ↓：将选中的代码向下复制一行
9、Ctrl + d：删除选中的行，连换行符也一起删掉
10、Alt + shift + r：给变量重命名（所有该变量一起改名字）
11、F2：修改类名，所有引用该类型的地方都会发生改变
基本的编辑快捷键：
Ctrl ：A、C、X、V、Z、Y
快速生成一个自定义类的方法
1、自定义类中的各种方法，可以使用快捷键生成
2、类中的成员变量，需要自己定义，成员变量的内容无法预测；
3、Alt + shift + s：操作有关源代码的快捷键
4、C：从父类生成各种构造方法（一般是空参构造）
5、O：根据自己的字段生成对应的构造方法
6、R：生成字段对应的get、set方法
7、S：生成字段对应的toString方法