黑马程序员——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();
}