一、抽象类概念和作用(abstract)
抽象类
抽象方法的特点:
- 只有方法头没有方法体的方法称为抽象方法
- 抽象方法用abstract来修饰
- 抽象方法代表一种不确定的操作或行为
- 抽象方法不能被调用
抽象类的特点:
- 定义中含有抽象方法的类叫做抽象类
- 抽象类用abstract来修饰
- 抽象类代表一种抽象的对象类型
- 抽象类不能实例化
- 抽象类中可以有具体方法,可以没有抽象方法
抽象类的使用方法 (抽象类不能实例化)
abstract class Demo1
{
abstract public void printInfo();
//在抽象类里面的方法,要么完善方法体,要么作为抽象方法
//没有方法体的方法,该方法由子类来具体实现
}
//抽象类不能实例化
public class Demo {
public static void main(String[] args) {
Demo1 d = new Demo1() {
public void printInfo() {
// TODO Auto-generated method stub
System.out.println("demo1 print");
}
};
d.printInfo();
}
}
abstract class Demo1//抽象类
{
abstract public void printInfo();//抽象方法
//在抽象类里面的方法,要么完善方法体,要么作为抽象方法
//没有方法体的方法,该方法由子类来具体实现
}
class Demo2 extends Demo1
{
public void printInfo() {
// TODO Auto-generated method stub
System.out.println("来自:Demo2");
}
}
public class Demo {
public static void main(String[] args) {
Demo2 d = new Demo2();
d.printInfo();
}
}
运行结果:
抽象类的应用:模板方法模式
abstract class Control
{
abstract void getCommand(); //是概括了在不同平台上完成智能家居项目的模板
abstract void socketCommand(); //抽象化这些方法,在子类(类比于具体平台)
abstract void lightControl(); //中再进行具体化
abstract void cameraControl();
public void work(){ //控制的基本流程
getCommand(); //接收指令
socketCommand(); //来自socket的指令
lightControl(); //灯的控制
cameraControl(); //相机的控制
}
}
class C51platform extends Control //当这个地方出现红色波浪线的时候
{ //光标放上去,可以看到解决方法的快捷键
//把抽象方法重写,全部具体实现
void getCommand() {
System.out.println("getcommand in 51");
}
void socketCommand() {
System.out.println("socketcommand in 51");
}
void lightControl() {
System.out.println("lightcontrol in 51");
}
void cameraControl() {
System.out.println("cameracontrol in 51");
}
}
public class Demo {
public static void main(String[] args) {
C51platform c51 = new C51platform(); //实例化出一个对象
c51.work(); //执行具体流程
}
}
二、接口
接口的概念
interface 接口名{
//公有静态常量、抽象方法(抽象方法用的比较多)
}
class 类名{
}
接口与类的区别
接口的特点
- 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)。
- 接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量(并且只能是 public,用 private 修饰会报编译错误)。
- 接口中的方法是不能在接口中实现的,只能由实现接口的类来实现接口中的方法。
接口的声明
interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}
-
接口是隐式抽象的,当声明一个接口的时候,不必使用abstract关键字。
-
接口中每一个方法也是隐式抽象的,声明时同样不需要abstract关键字。
-
接口中的方法都是公有的。
接口的使用
interface Behavior //接口,更注重方法
{
void eat(); //在接口中,不写修饰符,默认为隐式抽象
abstract void drink(); //当然写也无问题
}
class Man implements Behavior //一个类实现了这个接口
{ //从而来继承接口的抽象方法
public void eat() {
System.out.println("人吃米");
}
public void drink() {
System.out.println("人喝饮料");
}
}
class Dog implements Behavior //一个类实现了这个接口
{ //从而继承接口的抽象方法
public void eat() {
System.out.println("狗喜欢吃骨头");
}
public void drink() {
System.out.println("狗喝水");
}
}
public class Test {
public static void main(String[] args) {
Man m = new Man();
m.eat();
m.drink();
new Dog().eat();//new就是实例化一个对象,所以new Man()已经是一个对象了
new Dog().drink();
}
}
接口实现与抽象类继承的区别
class People implements Survival,EnjoyLife //people这个类实现了多个接口
接口的多继承
public interface Sport extends Basketball, Football,Ping_pong
interface Survival //人关于生存的行为
{
void eat();
void drink();
}
interface EnjoyLife //人享受生活的行为
{
void seeMovie();
}
interface HowPeopleLive extends Survival,EnjoyLife //这个接口继承了上面两个接口
{
void happy();
/*void life(){ 接口中不允许有方法体
}*/
void life(); //只能在类的实现中赋予方法体
}
class People implements HowPeopleLive
{
//当一个类实现接口时,就要把接口里所有的抽象方法实现,具体化
public void eat() {
System.out.println("主要吃大米饭");
}
public void drink() {
System.out.println("主要喝白开水");
}
public void seeMovie() {
System.out.println("看电影感悟生活");
}
public void happy() {
System.out.println("你开心就好");
}
public void life() { //实现接口的方法体
eat();
drink();
seeMovie();
happy();
}
}
public class Test {
public static void main(String[] args) {
People man = new People();
man.life();
}
}
三、 内部类
概念
public class Outer{
class Inner{
}
}
内部类的主要特点
成员内部类(使用较多)及应用
(1)创建成员内部类的实例
外部类名.内部类名 实例 = 外部类实例名.new 内部类构造方法(参数)
class Outer
{
int data;
void printData(){
System.out.println("外部类打印");
}
class Inner
{
int data;
void innerPrint(){
System.out.println("内部类打印");
}
}
}
public class Test {
public static void main(String[] args) {
Outer out = new Outer();//要使用内部类的方法,必须先实例化一个外部类的对象
Outer.Inner in = out.new Inner(); //再通过这个外部类的对象实例化一个内部类的对象
in.innerPrint();
}
}
(2)在成员内部类中访问外部类的成员方法和属性
外部类名.this.成员方法
//或者
外部类名.this.成员属性
class Outer
{
int data;
void printData(){
System.out.println("外部类打印");
}
class Inner
{
int data;
void innerPrint(){
System.out.println("内部类打印");
Outer.this.printData();//内部类对外部类方法的访问
System.out.println("内部类访问外部类的属性:data="+Outer.this.data);
}
}
}
public class Test {
public static void main(String[] args) {
Outer out = new Outer();//要使用内部类的方法,必须先实例化一个外部类的对象
out.data = 10;
Outer.Inner in = out.new Inner(); //再通过这个外部类的对象实例化一个内部类的对象
in.innerPrint();
}
}
(3)外部类不能直接访问内部类的成员,必须先建立内部类的对象才能访问
class Outer
{
int data;
void printData(){
System.out.println("外部类打印");
}
//外部类不能直接访问内部类的成员,必须先建立内部类的对象才能访问
void visitInner(){
Inner in = new Inner();//先建立内部类的对象
in.innerPrint(); //通过内部类的对象进行访问
}
class Inner
{
int data;
void innerPrint(){
System.out.println("内部类打印");
}
}
}
public class Test {
public static void main(String[] args) {
Outer out = new Outer();//要使用内部类的方法,必须先实例化一个外部类的对象
out.visitInner();
}
}
成员内部类有以下限制
四、匿名内部类
概念
匿名内部类的创建与访问
new interface/superclass(){类体}
(1)创建后立即访问
abstract class Demo1
{
abstract void printInfo();
}
public class Test {
public static void main(String[] args) {
new Demo1(){
void printInfo(){ //匿名内部类必须实现继承的类的所有方法
System.out.println("这不是demo1,而是匿名内部类的方法");
}
}.printInfo();//new的返回值就是一个对象,所以可以直接这样访问匿名内部类的方法
}
}
(2)当然,也可以用“多态”进行访问(目前我也不知道多态是啥)
abstract class Demo1
{
abstract void printInfo();
}
public class Test {
public static void main(String[] args) {
Demo1 d = new Demo1(){ //这感觉像是实例化了一个Demo1得到对象d,实际上得出的这个Demo1是抽象类的子类
void printInfo(){ //匿名内部类必须实现继承的类的所有方法
System.out.println("这不是demo1,而是匿名内部类的方法");
}
};
d.printInfo();
}
}
(3)匿名内部类实现一个接口
interface Demo2 //接口
{
abstract void interprint();
}
public class Test {
public static void main(String[] args) {
new Demo2(){
public void interprint(){ //这里不使用public就报错了
System.out.println("这不是接口的实例,而是匿名内部类的方法");
}
}.interprint();
}
}
评论(0)
您还未登录,请登录后发表或查看评论