黑马程序员——Java面向对象之抽象类 接口 内部类笔记
------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();
}
}
abstract关键字:
与这些关键字不能共存
private 冲突
final 冲突
static 无意义
四,接口概述
接口成员定义
1)变量 固定格式 修饰符必须完整
public static final
2)方法 固定格式 抽象方法，修饰符必须完整
public abstract
接口中没有构造方法,因为接口主要是扩展功能,而没有具体存在.
3)定义接口关键字interface
实现接口关键字implements
格式：class 类名 implements 接口名 {}
4)接口的使用
定义实现类，实现接口重写全部抽象方法，建立实现类对象
可以多态方式调用
5)关系
类与类
继承关系，只能单继承，但是可以多层继承
类与接口
实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口
接口与接口
继承关系，可以单继承，也可以多继承
6)抽象类和接口的区别
成员区别
抽象类 变量,常量;有抽象方法;抽象方法,非抽象方法
接口 常量;抽象方法
关系区别
类与类 继承，单继承
类与接口 实现，单实现，多实现
接口与接口 继承，单继承，多继承
设计理念区别
抽象类 被继承体现的是：”is a”的关系。共性功能
接口 被实现体现的是：”like a”的关系。扩展功能
示例:
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 关闭");
}
}五, 内部类概述
(成员内部类,局部内部类,匿名内部类)
把类定义在其他类的内部，这个类就被称为内部类。
举例：在类A中定义了一个类B，类B就是内部类。
内部类的访问特点：
内部类可以直接访问外部类的成员，包括私有。
外部类要访问内部类的成员，必须创建对象。
1),成员内部类
定义在外部类的成员位置.
创建内部类对象时:
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
示例:
/*
成员内部类 实现接口
*/
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();//内部类为静态,方法为非静态时.
//如果内部类非静态,则内部方法必须为为非静态. 生命周期的原因.
}
}2) 局部内部类
示例:
/*
局部内部类，定义在了外部类的方法里面
访问局部内部类中的成员，只能依赖外部类方法.
1)为什么，局部内部类，访问局部变量，必须加final
原因：生命周期
2)加上final 为什么就可以编译成功，和运行呢
原因: javac 检测代码中的结构 变量的值，终身不变
编译的时候，内部类的方法 x 变量，直接就替换成了5
*/
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();
}
}3)匿名内部类
格式：
new 父类或者接口(){
重写父类或者接口抽象方法
};
匿名类的前提:继承父类或者实现接口;
一个类实现接口步骤:重写方法,建立实现类对象,调用重写方法.
匿名内部类简化了上述步骤:到达一步实现的目的.
示例: 一步实现的示例
//定义接口
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();
}