java练习-接口07

1 接口的特点

接口的特点:
	A:接口用关键字interface表示	
		interface 接口名 {}
	B:类实现接口用implements表示
		class 类名 implements 接口名 {}
	C:接口不能实例化
		那么,接口如何实例化呢?
		按照多态的方式来实例化。AnimalTrain at=new Cat();
	D:接口的子类
		a:可以是抽象类。但是意义不大。
		b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

由此可见:
	A:具体类多态(几乎没有)
	B:抽象类多态(常用)
	C:接口多态(最常用)

//定义动物培训接口
interface AnimalTrain {
	public abstract void jump();
}

//抽象类实现接口
abstract class Dog implements AnimalTrain {
}

//具体类实现接口
class Cat implements AnimalTrain {
	public void jump() {
		System.out.println("猫可以跳高了");
	}
}

class InterfaceDemo {
	public static void main(String[] args) {
		//AnimalTrain是抽象的; 无法实例化
		//AnimalTrain at = new AnimalTrain();
		//at.jump();
		
		AnimalTrain at = new Cat();
		at.jump();
	}
}

接口成员特点
	成员变量；只能是常量,并且是静态的。
			默认修饰符:public static final
			建议:自己手动给出。
	构造方法:接口没有构造方法。
	成员方法:抽象方法。（最初）
			默认修饰符:public abstract
			建议:自己手动给出。
		Jdk1.8中可以有普通方法(default)，私有方法、静态方法
所有的类都默认继承自一个类:Object。
类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。

interface Inter {
	public int num = 10;
	public final int num2 = 20;
	public static final int num3 = 30;
	
	//错误: 需要<标识符>
	//public Inter() {}
	
	//接口方法不能带有主体
	//public void show() {}

	//abstract void show(); //默认public
	public void show(); //默认abstract
}

//接口名+Impl这种格式是接口的实现类格式
/*
class InterImpl implements Inter {
	public InterImpl() {
		super();
	}
}
*/

class InterImpl extends Object implements Inter {
	public InterImpl() {
		super();
	}
	
	public void show() {}
}

类与类:
	继承关系,只能单继承,可以多层继承。
类与接口:
	实现关系,可以单实现,也可以多实现。
	并且还可以在继承一个类的同时实现多个接口。
接口与接口:
	继承关系,可以单继承,也可以多继承。

package cn.plsite.day04.demo07;

public interface Inter {
    public int num = 10;
    //抽象方法
    void eat();
//    private void sleep(){
//        System.out.println("接口中私有方法");
//    }

    default void jump(){
        System.out.println("接口中普通方法");
       // sleep();
        staticMethond();
    }

    //永远不被使用？
    static void staticMethond(){
        System.out.println("接口中静态方法");
    }

}

package cn.plsite.day04.demo07;

public class Imp implements Inter {

    @Override
    public void eat() {
        System.out.println("实现类实现eat");
    }

}

package cn.plsite.day04.demo07;

public class Inter_Imp {
    public static void main(String[] arg){
        Imp imp = new Imp();
        imp.eat();
        imp.jump();
    }
}

结果：

实现类实现eat
接口中普通方法
接口中静态方法

---

2 抽象类和接口的区别

抽象类和接口的区别:
A:成员区别
	抽象类:
		成员变量:可以变量,也可以常量
		构造方法:有
		成员方法:可以抽象,也可以非抽象
	接口:
		成员变量:只可以常量
		成员方法:只可以抽象
		
B:关系区别
	类与类
		继承,单继承 
	类与接口
		实现,单实现,多实现
	接口与接口
		继承,单继承,多继承
		
C:设计理念区别
	抽象类被继承体现的是:”is a”的关系。抽象类中定义的是该继承体系内的共性功能。
	接口被实现体现的是:”has a”的关系。接口中定义的是该继承体系外的扩展功能。

---

3 运动员和教练案例实现

教练和运动员案例(学生分析然后讲解)
	乒乓球运动员和篮球运动员。
	乒乓球教练和篮球教练。
	为了出国交流,跟乒乓球相关的人员都需要学习英语。
	请用所学知识:
	分析,这个案例中有哪些抽象类,哪些接口,哪些具体类。

代码实现//定义一个说英语的接口
interface SpeakEnglish {
	//说英语
	public abstract void speak();
}

//定义人的抽象类
abstract class Person {
	private String name;
	private int age;
	
	public Person() {}
	
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	//睡觉
	public void sleep() {
		System.out.println("人都是要睡觉的");
	}
	
	//吃饭
	public abstract void eat();
}

//定义运动员抽象类
abstract class Player extends Person {
	public Player() {}
	
	public Player(String name,int age) {
		super(name,age);
	}
	
	//学习
	public abstract void study();
}

//定义教练抽象类
abstract class Coach extends Person {
	public Coach() {}
	
	public Coach(String name,int age) {
		super(name,age);
	}
	
	//教
	public abstract void teach();
}

//定义乒乓球运动员具体类
class PingPangPlayer extends Player implements SpeakEnglish {
	public PingPangPlayer(){}
	
	public PingPangPlayer(String name,int age) {
		super(name,age);
	}
	
	//吃
	public void eat() {
		System.out.println("乒乓球运动员吃大白菜,喝小米粥");
	}
	
	//学习
	public void study() {
		System.out.println("乒乓球运动员学习如何发球和接球");
	}
	
	//说英语
	public void speak() {
		System.out.println("乒乓球运动员说英语");
	}
}

//定义篮球运动员具体类
class BasketballPlayer extends Player {
	public BasketballPlayer(){}
	
	public BasketballPlayer(String name,int age) {
		super(name,age);
	}
	
	//吃
	public void eat() {
		System.out.println("篮球运动员吃牛肉,喝牛奶");
	}
	
	//学习
	public void study() {
		System.out.println("篮球运动员学习如何运球和投篮");
	}
}

//定义乒乓球教练具体类
class PingPangCoach extends Coach implements SpeakEnglish {
	public PingPangCoach(){}
	
	public PingPangCoach(String name,int age) {
		super(name,age);
	}
	
	//吃
	public void eat() {
		System.out.println("乒乓球教练吃小白菜,喝大米粥");
	}
	
	//教
	public void teach() {
		System.out.println("乒乓球教练教如何发球和接球");
	}
	
	//说英语
	public void speak() {
		System.out.println("乒乓球教练说英语");
	}
}

//定义篮球教练具体类
class BasketballCoach extends Coach {
	public BasketballCoach(){}
	
	public BasketballCoach(String name,int age) {
		super(name,age);
	}
	
	//吃
	public void eat() {
		System.out.println("篮球教练吃羊肉,喝羊奶");
	}
	
	//教
	public void teach() {
		System.out.println("篮球教练教如何运球和投篮");
	}
}

class InterfaceDemo {
	public static void main(String[] args) {
		//测试运动员(乒乓球运动员和篮球运动员)
		//乒乓球运动员
		PingPangPlayer ppp = new PingPangPlayer();
		ppp.setName("王浩");
		ppp.setAge(33);
		System.out.println(ppp.getName()+"---"+ppp.getAge());
		ppp.eat();
		ppp.sleep();
		ppp.study();
		ppp.speak();
		System.out.println("----------------");
		//通过带参构造给数据(留给你们)
		
		//篮球运动员
		BasketballPlayer bp = new BasketballPlayer();
		bp.setName("姚明");
		bp.setAge(34);
		System.out.println(bp.getName()+"---"+bp.getAge());
		bp.eat();
		bp.sleep();
		bp.study();
		//bp.speak(); //没有该方法
		
		//测试教练自己做
	}
}

---

4 接口名作为形式参数练习

package cn.plsite.day04.demo09;

public interface Love {

    //public abstract void love();public、abstract可以省略
void love();
}

package cn.plsite.day04.demo09;



public class Teacher implements Love {
    @Override
    public void love(){
        System.out.println("老师的爱好");
    }
}

package cn.plsite.day04.demo09;

public class LoveDemo {

    public void method(Love l){
        l.love();
    }
}

package cn.plsite.day04.demo09;

public class TeacherTest {
    public static void main(String[] args) {
        LoveDemo ld = new LoveDemo();
        Love l = new Teacher();
        ld.method(l);
    }
}

注意：接口作为形式参数时候，需要接口实现类对象

---

5 抽象类名作为形式参数练习

abstract class Person {
	public abstract void study();
}

class PersonDemo {
	public void method(Person p) {//p; p = new Student();  Person p = new Student(); //多态
		p.study();
	}
}

//定义一个具体的学生类
class Student extends Person {
	public void study() {
		System.out.println("Good Good Study,Day Day Up");
	}
}

class PersonTest {
	public static void main(String[] args) {
		//目前是没有办法的使用的
		//因为抽象类没有对应的具体类
		//那么,我们就应该先定义一个具体类
		//需求:我要使用PersonDemo类中的method()方法
		PersonDemo pd = new PersonDemo();
		Person p = new Student();
		pd.method(p);
	}
}

注意：抽象类子类对象作为形式参数

---

6 接口名作为返回值类型练习

interface Love {
	public abstract void love();
}

class LoveDemo {
	public Love getLove() {
		//Love l = new Teacher();
		//return l;
		
		return new Teacher();
	}
}

//定义具体类实现接口
class Teacher implements Love {
	public void love() {
		System.out.println("老师爱学生,爱Java,爱林青霞");
	}
}

class TeacherTest2 {
	public static void main(String[] args) {
		//如何测试呢?
		LoveDemo ld = new LoveDemo();
		Love l = ld.getLove(); //new Teacher(); Love l = new Teacher(); 多态
		l.love();
	}
}

---

7 抽象类名作为返回值类型练习

abstract class Person {
	public abstract void study();
}

class PersonDemo {
	public Person getPerson() {
		//Person p = new Student();
		//return p;
		
		return new Student();
	}
}

class Student extends Person {
	public void study() {
		System.out.println("Good Good Study,Day Day Up");
	}
}

class PersonTest2 {
	public static void main(String[] args) {
		//需求:我要测试Person类中的study()方法
		PersonDemo pd = new PersonDemo();
		Person p = pd.getPerson(); //new Student();  Person p = new Student(); 多态
		p.study();
	}
}

8 package关键字的概述及作用

包:
	A:其实就是文件夹
	B:作用
		a:把相同的类名放到不同的包中
		b:对类进行分类管理
		
举例:
	学生:增加,删除,修改,查询
	老师:增加,删除,修改,查询
	...
	
	方案1:按照功能分
		cn.itcast.add
			AddStudent
			AddTeacher
		cn.itcast.delete
			DeleteStudent
			DeleteTeacher
		cn.itcast.update
			UpdateStudent
			UpdateTeacher
		cn.itcast.find
			FindStudent
			FindTeacher
	
	方案2:按照模块分
		cn.itcast.teacher
			AddTeacher
			DeleteTeacher
			UpdateTeacher
			FindTeacher
		cn.itcast.student
			AddStudent
			DeleteStudent
			UpdateStudent
			FindStudent
			
包的定义
	package 包名;
		多级包用.分开即可


注意事项:
	A:package语句必须是程序的第一条可执行的代码
	B:package语句在一个java文件中只能有一个
	C:如果没有package,默认表示无包名
	
带包的编译和运行:
	A:手动式
		a:编写一个带包的java文件。
		b:通过javac命令编译该java文件。
		c:手动创建包名。
		d:把b步骤的class文件放到c步骤的最底层包
		e:回到和包根目录在同一目录的地方,然后运行
			带包运行。
			
	B:自动式
		a:编写一个带包的java文件。
		b:javac编译的时候带上-d即可
			javac -d . HelloWorld.java
		c:回到和包根目录在同一目录的地方,然后运行
			带包运行。

9 import关键字的概述和使用

导包:
	格式:import 包名;
		这种方式导入是到类的名称。
	注意:我们用谁就导谁。
	
面试题:
	package,import,class有没有顺序关系?
	有。
	package > import > class
	
	Package:只能有一个
	import:可以有多个
	class:可以有多个,以后建议是一个

package cn.itcast;

import com.liuyi.Demo;

class Test {
	public static void main(String[] args) {
		//Demo d = new Demo();
		/*
		com.liuyi.Demo d = new com.liuyi.Demo();
		System.out.println(d.sum(10,20));
		
		com.liuyi.Demo d2 = new com.liuyi.Demo();
		System.out.println(d2.sum(10,20));
		
		com.liuyi.Demo d3 = new com.liuyi.Demo();
		System.out.println(d3.sum(10,20));
		
		com.liuyi.Demo d4 = new com.liuyi.Demo();
		System.out.println(d4.sum(10,20));
		*/
		
		Demo d = new Demo();
		System.out.println(d.sum(10,20));
	}
}

第一个问题:找不到Demo

第二个问题:程序包com.liuyi不存在

第三个问题: Demo在com.liuyi中不是公共的; 无法从外部程序包中对其进行访问

10 四种权限修饰符的测试

权限修饰符:
				 本类   	同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
	private 	  Y		
	默认		  	  Y		     	Y
	Protected     Y	            Y				    Y
	public		  Y		        Y				    Y				Y

package com.liuyi;

public class Father {
	private void show() {
		System.out.println("show");
	}
	
	void show2() {
		System.out.println("show2");
	}
	
	protected void show3() {
		System.out.println("show3");
	}
	
	public void show4() {
		System.out.println("show4");
	}
	
	public static void main(String[] args) {
		Father f = new Father();
		f.show();
		f.show2();
		f.show3();
		f.show4();
	}
}

11 类及其组成所使用的常见修饰符

修饰符:
	权限修饰符:private,默认,protected,public
	状态修饰符:static,final
	抽象修饰符:abstract
	
类:
	权限修饰符:默认修饰符,public
	状态修饰符:final
	抽象修饰符:abstract
	
	用的最多的就是:public
	
成员变量:
	权限修饰符:private,默认的,protected,public
	状态修饰符:static,final
	
	用的最多的就是:private
	
构造方法:
	权限修饰符:private,默认的,protected,public
	
	用的最多的就是:public
	
成员方法:
	权限修饰符:private,默认的,protected,public
	状态修饰符:static,final
	抽象修饰符:abstract
	
	用的最多的就是:public
	
除此以外的组合规则:
	成员变量:public static final
	成员方法:public static 
	          public abstract
			  public final

//此处不允许使用修饰符private
//此处不允许使用修饰符protected
//此处不允许使用修饰符static
public class Demo {
	//成员变量
	private int x = 10;
	int y = 20;
	protected int z = 30;
	public int a = 40;
	public final int b = 50;
	public static int c = 60;
	public static final int d = 70;
	//此处不允许使用修饰符abstract
	//abstract int e = 80;
	
	//构造方法
	private Demo(){}
	
	Demo(String name){}
	
	protected Demo(String name,int age) {}
	
	public Demo(String name,int age,String address) {}
	
	//此处不允许使用修饰符static
	//public static Demo(){}
	//此处不允许使用修饰符final
	//public final Demo() {}
	//此处不允许使用修饰符abstract
	//public abstract Demo(){}
	
	//成员方法
	//static void show() {}
	//abstract void show();
	//final void show(){}
}