10_接口丶内部类丶权限修饰符
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方法