java语言的继承是单一继承,一个子类只有一个父类
java语言提供了一种机制,用于处理继承单一的局限性:接口
接口:接口是一个比抽象类还抽象的类,接口里面的所有方法都是抽象方法,接口和类的关系是实现:implement
接口的格式:
interface 接口名{
}
接口的描述
接口是功能的集合,同样可看做是一种数据类型,是比抽象类更为抽象的”类”。
接口只描述所应该具备的方法,并没有具体实现,具体的实现由接口的实现类(相当于接口的子类)来完成。
这样将功能的定义与实现分离,优化了程序设计
接口的成员特点:
只有抽象方法
只能有常量,默认使用修饰符public static final 修饰常量
只能使用public&abstract修饰方法
注:
接口不能创建对象(即不能被实例化)
类与接口的关系是实现关系,一个类实现一个接口必须实现她的所有方法
接口和类之间的关系
类与类:继承关系,单一继承,多层继承
类与接口:实现关系,多实现
接口与接口:继承关系,多层继承
public class InterfaceDemo3 {
public static void main(String[] args) {
}
}
interface InterA extends InterB {
public abstract void method();
}
interface InterB {
public abstract void function();
}
interface InterC extends InterA {
}
class Demo implements InterC {
@Override
public void method() {
// TODO Auto-generated method stub
}
@Override
public void function() {
// TODO Auto-generated method stub
}
}
接口的优点
1、打破了继承的局限性
2、对外提供规则
3、降低了程序的耦合性,可以实现模块化开发,提高了开发的效率
接口与抽象类的区别
共性:不断的抽取出抽象的概念
区别:
1、与类的关系
类与接口是实现关系,而且是多实现,一个类可以实现多个接口
类与抽象类是继承关系,java的继承是单一继承,一个类只能有一个父类,java中的继承是多层继承
2、成员
成员变量:
抽象类可以有成员变量,也可以有常量
接口只能有常量
成员方法:
抽象类可以有抽象方法,也可以有非抽象方法
接口只能有抽象方法,而且方法默认修饰符public abstract
构造方法:
抽象类有构造方法
接口没有构造方法
案例分析:
public class InterfaceTest {
public static void main(String[] args) {
//创建篮球运动员对象
BasketBallPlayer bbp = new BasketBallPlayer();
bbp.name = "女兆月日";
bbp.age = 35;
bbp.gender = "男";
bbp.sleep();
bbp.study();
bbp.speak();
System.out.println("-------------");
//创建乒乓球教练对象
PingpangCoach ppc = new PingpangCoach();
ppc.name = "刘胖子";
ppc.age = 40;
ppc.gender = "男";
ppc.sleep();
ppc.teach();
//ppc.speak();
}
}
class Person {
String name;//姓名
int age;//年龄
String gender;//性别
//无参构造
public Person() {}
//有参构造
public Person(String name,int age,String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
//吃
public void eat() {
System.out.println("吃饭");
}
//睡
public void sleep() {
System.out.println("睡觉");
}
}
//学习说英语
interface SpeakEnglish {
public abstract void speak();
}
//运动员
abstract class Player extends Person {
//学习
public abstract void study();
}
//教练
abstract class Coach extends Person {
//教
public abstract void teach();
}
//篮球运动员
class BasketBallPlayer extends Player implements SpeakEnglish{
@Override
public void study() {
System.out.println("学扣篮");
}
@Override
public void speak() {
System.out.println("说英语");
}
}
//乒乓球运动员
class PingpangPlayer extends Player {
@Override
public void study() {
System.out.println("学抽球");
}
}
//篮球教练
class BasketBallCoach extends Coach implements SpeakEnglish {
@Override
public void teach() {
System.out.println("教扣篮");
}
@Override
public void speak() {
System.out.println("说英语");
}
}
//乒乓球教练
class PingpangCoach extends Coach {
@Override
public void teach() {
System.out.println("教抽球");
}
}
匿名对象的概述和应用场景
匿名对象:即无名对象,直接使用new关键字来创建对象
匿名对象的应用场景:
当方法只调用一次的时候可以使用匿名对象
可以当作参数进行传递,但是无法在传参之前做其他的事情
public class AnonymousObejctDemo {
public static void main(String[] args) {
//Student s = new Student();
//s.study();
//s.study();
//s.study();
//new Student();//匿名对象,没有变量引用的对象
//new Student().study();
//new Student().study();
//new Student().study();
//new Student().age = 18;
//System.out.println(new Student().age);
//Student s = new Student();
//s.age = 18;
//s.name = "张三";
//method(s);
method(new Student());
}
public static void method(Student s) {
}
}
class Student {
String name;
int age;
public void study() {
System.out.println("好好学习,高薪就业");
}
}
final的概述和作用
final:修饰符,可以用于修饰类、成员方法、成员变量
final所修饰的类,不能被继承,不能有子类
final所修饰的方法:不能被子类重写
final所修饰的变量:不能被修改,是常量
常量:
字面值常量:1、2、3
自定义常量:被final所修饰的成员变量,一旦被初始化就不可改变,一般使用英文大写
注:自定义常量必须初始化,可以选择显示初始化或者构造初始化
多态
多态是继封装、继承之后,面向对象的第三大特性。
多态的前提:
字符类的继承关系
方法的重写
父类引用指向子类对象:Animal a = new Cat()
动态绑定:
运行期间调用的方法,是根据其具体的类型
多态成员的特点:
成员变量:
当子父类中出现同名的成员变量时,多态调用该变量时:
编译时期:参考的是引用型变量所属的类中是否有被调用的成员变量。
没有,编译失败。
运行时期:也是调用引用型变量所属的类中的成员变量。
简单记:编译和运行都参考等号的左边。编译运行看左边。
成员方法
编译时期:参考引用变量所属的类,如果没有类中没有调用的方法,编译失败。
运行时期:参考引用变量所指的对象所属的类,并运行对象所属类中的成员方法。
简而言之:编译看左边,运行看右边
package com.itheima_01;
/*
*
* 多态的成员特点:
* 成员变量 编译时看的是左边,运行时看的左边
* 成员方法 编译时看的是左边,运行时看右边
* 静态方法 编译时看的是左边,运行时看的也是左边
*
*
* 编译时看的都是左边,运行时成员方法看的是右边,其他(成员变量和静态的方法)看的都是左边
*
*/
public class PoymorphicDemo2 {
public static void main(String[] args) {
Dad d = new Kid();
//System.out.println(d.num);
//d.method();
d.function();//使用变量去调用静态方法,其实相当于用变量类型的类名去调用
}
}
class Dad {
int num = 20;
public void method() {
System.out.println("我是父类方法");
}
public static void function() {
System.out.println("我是父类静态方法");
}
}
class Kid extends Dad {
int num = 10;
public void method() {
System.out.println("我是子类方法");
}
public static void function() {
System.out.println("我是子类静态方法");
}
}
多态的向上转型与向下转型
多态的转型分为向上转型与向下转型两种:
A:向上转型:当有子类对象赋值给一个父类引用时,便是向上转型,多态本身就是向上转型的过程。
使用格式:
父类类型 变量名 = new 子类类型();
如:Person p = new Student();
B:向下转型:一个已经向上转型的子类对象可以使用强制类型转换的格式,将父类引用转为子类引用,这个过程是向下转型。如果是直接创建父类对象,是无法向下转型的
使用格式:
子类类型 变量名 = (子类类型) 父类类型的变量;
如:Student stu = (Student) p; //变量p 实际上指向Student对象
引用类型之间的转换
扫描二维码关注公众号,回复:
11499799 查看本文章
向上转型
由小到大(子类型转换成父类型)
向下转型
由大到小
基本数据类型的转换
自动类型转换
由小到大
byte short char --- int --- long --- float --- double
强制类型转换
由大到小
public class PoymorphicDemo3 {
public static void main(String[] args) {
Animal2 a = new Dog();//向上转型
//a.eat();调用子类的eat方法,但是编译时看父类是否有eat方法,若无,则编译出错
Dog d = (Dog)a;//向下转型
d.swim();
}
}
class Animal2 {
public void eat() {
System.out.println("吃东西");
}
}
class Dog extends Animal2 {
public void eat() {
System.out.println("啃骨头");
}
public void swim() {
System.out.println("狗刨");
}
}
多态的优缺点
缺点:不能直接访问子类特有的成员
优点:可以提高可维护性(多态前提所保证),提高代码的可扩展性
public class PoymorphicDemo4 {
public static void main(String[] args) {
MiFactory factory = new MiFactory();
factory.createPhone(new MiNote());
factory.createPhone(new RedMi());
}
}
class MiFactory {
/*public void createPhone(MiNote mi) {
mi.call();
}
public void createPhone(RedMi mi) {
mi.call();
}*/
public void createPhone(Phone p) {
p.call();
}
}
interface Phone {
public void call();
}
//小米Note
class MiNote implements Phone{
public void call() {
System.out.println("小米Note打电话");
}
}
//红米
class RedMi implements Phone {
public void call() {
System.out.println("红米打电话");
}
}