20160720(B) 接口及其特点/接口中的成员/其他细节/使用接口和抽象类的例子/抽象类和接口的区别/

接口

 abstract class Animal
  { 
	  abstract void show();
	  abstract void say();
	  abstract void say1();
	  abstract void say2();
  }

针对上面的问题,java提出另一种写法,就是接口
1. 格式:
interface 接口名
{
(abstract) void show();//接口当中的方法是没有实现的(抽象方法)
接口中省去了
这个关键字
}

2.如何使用接口(接口需要实现),实现implements
//class Dog extends Animal
class Dog implements Animal

interface Animal
{
void show();
}
//狗狗实现类
class Dog implements Animal
{
void show()
{
... //具体的实现
}
}

接口特点:

1.使用interface关键字来描述,接口里面的方法没有具体实现,类与接口之间通过implements关键字来实现
2.接口中的方法必须使用public来修饰,抽象方法可以使用"默认"权限(default)
3.接口不能被"实例化",因为接口中没有具体实现的方法
4.Animal.show(); 不能使用static关键字描述
   (静态的方法可以通过类直接调用)
5.不能使用final关键字修饰,其定义的方法不能"复写修改",但是接口中的方法需要去被实现("重写")

interface Animals
{
	public void show();//接口并没有具体实现④,用static无意义
	//默认             //需要子类(实现类)去实现,定义private就无法实现
}

class DogImpl implements Animals//Impl就是实现的意思
{
	public void show()//默认的权限不够
		{
		  System.out.println("接口Animal实现");//具体的方法
	    }
}
class  Eemon1
{
	public static void main(String[] args) 
	{
		DogImpl dogimpl=new DogImpl();
		dogimpl.show();
       
	   //Animal a=new Animal();//无论接口和抽象类,都是抽象的,无法实例化
        
	}
}

接口中的成员

1.成员属性(常量):

接口中是可以有成员"常量"的,而且"实现类"可以继承.
默认有public, final修饰,写程序的时候建议都加上
默认还有static修饰成员变量--①
说明接口中的成员常量都是静态的.(通过类的方式直接调用)

2.成员方法 默认是public权限,默认的abstract(没有方法体).默认都是公共的抽象方法
为什么是public?我们申明的抽象方法是要具体被实现的,还要被继承和复写,所以权限只能是最大的

3.构造函数?有吗?
接口没有构造函数

Q:为什么接口没有构造函数?
A:接口中没有成员变量,只有成员静态常量,和成员公共的抽象方法

interface Animal
{
<span style="white-space:pre">	</span>/*Animal()
<span style="white-space:pre">		</span>{
<span style="white-space:pre">		</span>  System.out.println("接口构造函数");//new构造函数没有什么用,因为不需要初始化什么方法
<span style="white-space:pre">	</span>    }*/
<span style="white-space:pre">	</span>public static final int age=20;//不能被改变,证明有final


<span style="white-space:pre">	</span>public void show();//默认public
}


//实现类
class Dog implements Animal
{
<span style="white-space:pre">	</span>public void show()//此处默认的不是public
<span style="white-space:pre">		</span>{
<span style="white-space:pre">		</span>  //age=30;//这里是错误的,被final修饰的变量不能被修改
<span style="white-space:pre">		</span>  System.out.println(age);
<span style="white-space:pre">	</span>    }
}


class Eemon2 
{
<span style="white-space:pre">	</span>public static void main(String[] args) 
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>Dog dog=new Dog();
<span style="white-space:pre">		</span>dog.show();//--20


<span style="white-space:pre">		</span>System.out.println(Animal.age);//①--20  静态修饰,可通过接口名直接调用
<span style="white-space:pre">	</span>}
}

接口其他细节:

    1.接口可以多实现 class C implements A,B  就是一个类可以实现多个接口


2.继承-- 接口可以多继承接口


注意:类与类只能 单 继承

interface A
{
	void showA();
}

interface B
{
	void showB();
}

class C implements A,B
{
	public void showA()
		{
		  System.out.println("A");
	    }

   public void showB()
	   {
	     System.out.println("B");

       }
}

/*接口继承关系*/
interface Inter1
{
}

interface Inter2
{
}

interface Inter3 extends Inter1,Inter2
{
}

class Eemon3 
{
	public static void main(String[] args) 
	{   
		//接口多实现
		C c=new C();
		c.showA();
		c.showB();

		//接口多继承(用处?)

	}
}

使用接口和抽象类的例子

  学生 姓名,年龄 学习(但不知道具体学习什么)
  老师 姓名,年龄 学习(但不知道具体学习什么)

  抽象类 姓名,年龄 将学习方法写成抽象方法?


  有些同学抽烟

<pre name="code" class="java">interface smoking
{
	public void smoking();
}

abstract class Person
{
	String name;
	int age;
	public abstract void study();

	//在这里定义抽烟不合适,不是所有的老师和学生都抽烟
}

class Student extends Person implements smoking//继承类,同时实现接口
{
	public void smoking()
		{
		 System.out.println("学生抽烟");
	    }
	public void study()
		{
	      System.out.println("学习javase基础");
        }
}

class Teacher extends Person
{
	public void study()
		{
		System.out.println("学习大数据");
	    }
}
class  Eemon4
{
	public static void main(String[] args) 
	{
		//学生
		Student s=new Student();
		s.study();//输出:<span style="font-family: Arial, Helvetica, sans-serif;">学生抽烟</span>
		s.smoking();//输出:<span style="font-family: Arial, Helvetica, sans-serif;">学习javase基础</span>


		//老师
		Teacher t=new Teacher();
		t.study();//输出:<span style="font-family: Arial, Helvetica, sans-serif;">学习大数据</span>

	}
}

.

抽象类和接口的区别:


  1.抽象类只能单继承
    接口可以多实现


  2.抽象类中可以有成员变量,可以是public ,static, final
    但是接口当中只有静态的常量public+static+final


<span style="white-space:pre">	</span>抽象类中可以有抽象方法,也可以有具体方法
<span style="white-space:pre">	</span>但接口只能有共有的抽象方法


<span style="white-space:pre">	</span>抽象类有 空参 构造函数, 单个参数 的构造函数
<span style="white-space:pre">	</span>接口没有构造函数


  3.抽象类实现单继承
    接口可以实现多继承