1.0 知识目标
1.0 掌握抽象类和抽象方法的定义形式
2.0 了解抽象类与继承的必然关系
3.0 掌握接口定义中成员的特点
4.0 掌握接口实现的具体要求
5.0* 掌握内嵌类的定义和使用特点
抽象类刚接触的人觉得没什么卵用,深入学习后自然就知道有什么卵用了
2.0 抽象类和抽象方法
1.0 抽象类的定义形式
用 abstract 关键字修饰
//下面这个就是抽象类,用abstract关键字标识
// 不可以呗实例化,只能够继承,并且抽象方法要在各个子类中实现
abstract class student{
成员变量定义
方法(){};
abstract 方法();//这就是抽象方法
//这是具体的抽象方法写法,没有大括号啥的,可以有形参
//抽象方法不定义方法体,只会在继承这个方法的子类中实现
abstract void setName();
}
下面看个例子
//这是抽象类
package b;
public abstract class AbstractTest {
int theLong;
int theWidth;
public abstract void sayLong();
abstract void sayWidth();
}
//这是抽象类的一个实现
package b;
public class Test extends AbstractTest {
@Override
public void sayLong() {
System.out.println("这个长度是"+theLong);
}
@Override
void sayWidth() {
System.out.println("这个长度是"+theWidth);
}
}
//这是另一个实现 也就是子类
package b;
public class Test1 extends AbstractTest {
@Override
public void sayLong() {
System.out.println("哦 这样啊 sayLong");
}
@Override
void sayWidth() {
System.out.println("哦 sayWidth");
}
}
//下面是测试类
package b;
public class Test2 {
public static void main(String[] args) {
Test test = new Test();
test.theLong = 10;
test.theWidth= 1;
test.sayLong();
test.sayWidth();
//还可以用父类变量存放子类对象的引用,例如
AbstractTest abstractTest = new Test();
AbstractTest abstractTest1 = new Test1();
abstractTest.theLong = 101;
abstractTest.theWidth= 11;
abstractTest.sayLong();
abstractTest.sayWidth();
abstractTest1.sayLong();
abstractTest1.sayWidth();
}
}
结果:
这个长度是10
这个长度是1
这个长度是101
这个长度是11
哦 这样啊 sayLong
哦 sayWidth
其他不多说,
AbstractTest abstractTest = new Test();
AbstractTest abstractTest1 = new Test1();
这里用父类变量去存放对象的引用,实际上就是用父类对象去访问具体的子类方法,这种也叫运行时的多态
下面是项目目录结构
3.0 接口
1.0 还是接口的定义形式
[public] abstract interface 接口名 [extends 父接口的列表多个用逗号隔开]{
[public][static][final]类型 变量名 = 常量值;
[public] [abstract] 返回值 函数名(参数列表) [throw 异常列表];
}
/*
1.0 []里的内容是可有可无的
2.0 接口具有继承性,一个接口可以继承多个接口 用逗号分隔//这里注意 java不能单继承是针对类的
3.0 接口中的所有常量都是静态常量 默认修饰是 public static final
4.0 接口中所有方法的修饰符都是public static
5.0 接口是抽象类的一种
*/
2.0 接口的实现
- 一个类可以实现多个接口,中间用逗号隔开,用implement来实现接口
- 接口里的默认方法是public的抽象方法,实现的时候要在方法显示的加public
- 如果实现接口时候没有实现a所有的方法,则会提示错误
接着看例子
//父接口1
package c;
public interface Animal{
int head = 1;//可有可无 默认类型是静态常量 public的
void eatFood();//这个默认的作用域是public
public void walk();
}
//父接口2
package c;
public interface Thing {
void setHeight();
}
//接口1
package c;
public interface Bird extends Animal, Thing {
void Fly();
}
//实现接口
package c;
public class Imp implements Bird {
@Override
public void eatFood() {
System.out.println("public void eatFood(");
}
@Override
public void walk() {
System.out.println("public void walk()");
}
@Override
public void setHeight() {
System.out.println("public void setHeight()");
}
@Override
public void Fly() {
System.out.println("public void Fly()");
}
public static void main(String[] args) {
Imp imp = new Imp();
imp.eatFood();
imp.Fly();
imp.setHeight();
imp.walk()
;
System.out.println(imp.head);
}
}
结果
public void eatFood(
public void Fly()
public void setHeight()
public void walk()
1
目录结构
这个接口啥的看的很清楚 就不多bb了
这里接口类型的变量,也可以用来做实现类对象的引用
public static void main(String[] args) {
Bird imp = new Imp();
imp.eatFood();
imp.Fly();
imp.setHeight();
imp.walk()
;
System.out.println(imp.head);
}
总结一下接口和抽象类的区别
1 接口里只能包含抽象方法,静态方法和默认方法,抽象类则完全可以包含普通方法。
2 接口里只能定义静态常量,不能定义普通成员变量,抽象类里则既可以定义普通成员变量,也可以定义静态常量。
3 接口不能包含构造器,抽象类可以包含构造器,抽象类里的构造器并不是用于创建对象,而是让其子类调用这些构造器来完成属于抽象类的初始化操作。
4 接口里不能包含初始化块,但抽象类里完全可以包含初始化块。
5 一个类最多只能有一个直接父类,包括抽象类,但一个类可以直接实现多个接口,通过实现多个接口可以弥补Java单继承不足。
4.0 内嵌类 (嵌套类)
1.0 静态内嵌类
package d;
public class StaticInnerClass {
void outerMethod(){
System.out.println("这是外部类的方法");
}
public static class inner{
public void innerMethod(){
System.out.println("实例方法 内嵌类");
}
public static void innerMethod1(){
System.out.println("静态类只能访问静态的东西");
}
}
public static void main(String[] args) {
StaticInnerClass.inner.innerMethod1();//直接访问静态内嵌类的静态方法
new StaticInnerClass.inner().innerMethod();//对象访问成员方法
}
}
2.0 成员内嵌类
package d;
public class StaticInnerClass {
void outerMethod(){
inner name = new inner();
name.innerMethod();
}
public class inner{
public void innerMethod(){
System.out.println("实例方法 内嵌类");
}
}
public static void main(String[] args) {
StaticInnerClass class1 = new StaticInnerClass();
class1.outerMethod();//对象访问成员方法
}
}
3.0 方法中的内嵌类
package d;
public class StaticInnerClass {
void outerMethod(){
class inner{
public void innerMethod(){
System.out.println("实例方法 内嵌类");
}
}
new inner().innerMethod();
}
public static void main(String[] args) {
StaticInnerClass class1 = new StaticInnerClass();
class1.outerMethod();//对象访问成员方法
}
}
4.0 匿名内嵌类
package d;
public class StaticInnerClass {
void outerMethod()
{
new inner()//这里会报错 需要编写一个接口
{
public void innerMethod()
{
System.out.println("实例方法 内嵌类");
}
}.innerMethod();
}
public static void main(String[] args) {
StaticInnerClass class1 = new StaticInnerClass();
class1.outerMethod();//对象访问成员方法
}
}
package d;
public interface inner {
}
目录结构