------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
三, 抽象类概述:
在Java中,一个没有方法体的方法应该定义为抽象方法,
而类中如果有抽象方法,该类必须定义为抽象类。
父类或者接口引用指向自己的子类对象
类 变量 = new 和前面的类不同();
前面:父类,可能是接口
后面:子类或者实现类 ,调用方法子类重写
抽象类特点
1)抽象类和抽象方法必须用abstract关键字修饰
格式
abstract class 类名 {}
public abstract void eat();
2)抽象类不一定有抽象方法,有抽象方法的类一定是抽象类
抽象类不能实例化
3)按照多态的方式,由具体的子类实例化。其实这也是多态的一种,抽象类多态。
抽象类的子类,要么是抽象类,要么重写抽象类中的所有抽象方法.
抽象类的成员特点
1)成员变量
可以是变量
也可以是常量
2)构造方法
有构造方法,但是不能实例化
构造方法的作用是,用于子类访问父类数据的初始化
3)成员方法
可以有抽象方法 限定子类必须完成某些动作
也可以有非抽象方法 提高代码复用性.
示例:
/*
员工: 姓名\ 工号\ 工作\
经理: 姓名\工号\工作\ 奖金
*/
//打工者
abstract class Employ{
//成员变量,定义为私有
private String name;
private String id;
//构造方法,为变量赋值
Employ(String name,String id){
this.name=name;
this.id=id;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setId(String id){
this.id=id;
}
public String getId(){
return id;
}
//抽象方法;
abstract void work();
}
//程序员
class Proger extends Employ{
//对应构造器
Proger(String name,String id){
//指向父类,
super(name,id);
}
//实现父类的抽象方法
void work(){
System.out.println("名字是"+getName()+"工号是"+getId()+"敲代码");
}
}
// 项目经理
class Manager extends Employ{
Manager(String name,String id,double bonus ){
super(name, id);//寻找父类构造器赋值.
this.bonus=bonus;//赋值给特有成员变量
}
//子类特有成员变量. 通过子类构造器来赋值. 其他非特有属性通过父类构造器来赋值.
double bonus;
//实现父类抽象方法
void work(){
System.out.println("名字是"+getName()+"工号是"+getId()+"奖金是"+bonus+"管理员工");
}
}
class YuanGongDemo{
public static void main(String[]args){
new Proger("张三","技术部001").work();
new Manager("李四","管理部002",1987367.89).work();
}
}
interface MyInterface
{
public static final int X = 1;
public abstract void show();
public abstract void show2();
}
//定义实现类,实现接口,重写全部抽象方法
class MyInterfaceImpl implements MyInterface
{
public void show(){
System.out.println("实现类,实现接口重写抽象方法");
}
}
class InterfaceDemo1
{
public static void main(String[] args)
{
//接口名直接调用自己的静态成员
System.out.println(MyInterface.X);
//实现类的名字,调用接口静态成员
System.out.println(MyInterfaceImpl.X);
MyInterfaceImpl my = new MyInterfaceImpl();
my.show();
//实现类的对象,调用接口中的静态成员
System.out.println(my.X);
}
}
//笔记本接口
interface USB{
public abstract void open();
public abstract void clase();
}
//笔记本
class BookPC{
public static void main(String[]args){
useUSB(null);
}
public static void useUSB(USB u){
u.open();
u.close();
}
}
//优盘实现USB接口
class Upan implements USB {
public abstract void open(){
System.out.println("Upan 打开");
}
public abstract void close(){
System.out.println("Upan 关闭");
}
}
/*
成员内部类 实现接口
*/
interface A
{
void inner();
}
class Outer
{
//定义为私有,只有通过外部类来调用
private class Inner implements A
{
//实现接口中的抽象方法
public void inner(){
System.out.println("inner");
}
}
public A get(){
return new Inner();
}
}
class InnerClassDemo3
{
public static void main(String[] args)
{
Outer o = new Outer();
A a = o.get();
a.inner();
//Outer.Inner i = o.get();
}
}
class Outer1
{
int x = 1;
class Inner
{
int x = 2;
public void show(){
int x = 3;
//输出1
System.out.println(Outer1.this.x);
//输出2
System.out.println(this.x);
//输出3
System.out.println(x);
}
}
}
public class ChengYuanNeibuLei
{
public static void main(String[] args)
{
//定义内部类对象
Outer1.Inner oi = new Outer1().new Inner();
//调用内部类中的方法
oi.show();
}
}
示例:
/*
内部类的三种格式
*/
class Outer{
static class Inter{
static void show(){
System.out.println("内部方法");
}
}
}
class IOterDemo{
public static void main(String[]args){
new Outer().new Inter().show();//内部类\方法均为非静态时
Outer.Inter.show();//内部类为静态,方法也为静态时.new Outer. Inter().show();也可行.
new Outer.Inter().show();//内部类为静态,方法为非静态时.
//如果内部类非静态,则内部方法必须为为非静态. 生命周期的原因.
}
}
interface A
{
void inner();
}
class Outer
{
//外部类的成员方法
public A out(){
//必须用final修饰
final int x = 5;
//定义在成员方法内部的类.并且实现了外部接口A
class Inner implements A
{
public void inner(){
System.out.println("abc "+x);
}
}
//提现了 依赖外部类中成员方法.
return new Inner();
}
}
class InnerClassDemo4
{
public static void main(String[] args)
{
Outer o = new Outer();
A a = o.out();
//访问局部内部类中的成员(方法inner()),只能依赖外部类方法.
a.inner();
}
}
匿名内部类简化了上述步骤:到达一步实现的目的.
示例: 一步实现的示例
//定义接口
interface MyInter{
//抽象方法
public abstract void show();
}
//接口的实现类
class MyInterImpl implements MyInter{
public void show(){
System.out.println("实现接口中的抽象方法");
}
//实现类中的其他方法
public void show1(){
}
public void show2(){
}
}
//入口所在类
class NiMIngDemo{
public static void main(String[]args){
//直接new接口名
new MyInter(){
//直接实现接口中的抽象方法
public void show(){
System.out.println("实现接口中的抽象方法");
}
//new 接口名,并实现抽象方法后,已成了 匿名对象.可以直接调方法
}.show1();
}