Javase进阶笔记-day02

学习目标

能够描述final修饰的类的特点  最终类(太监类),不能被继承
能够描述final修饰的方法的特点    最终方法,可以被继承,不能被重写
能够描述final修饰的变量的特点是一个常量,值不能改变
能够掌握static关键字修饰的变量调用方式类名.静态成员变量public class Person{static int a = 10;}Person.a;
能够掌握static关键字修饰的方法调用方式类名.静态成员方法(参数);public class Person{public static void show(int a){}}Person.show(10);
能够写出接口的定义格式public interface 接口名{抽象方法 public abstract 返回值类型 方法名(参数);默认方法 public default 返回值类型 方法名(参数){方法体}静态方法 public static 返回值类型 方法名(参数){方法体}}
能够写出接口的实现格式public class 实现类 implements 接口{}
能够说出接口中的成员特点变量:接口中的变量都是常量,有固定的修饰符 public static final int AAA = 10;方法:抽象方法(需实现类重写) 默认方法(实现类可以选择性重写) 静态方法(不能重写,使用接口名直接调用)接口中没有构造方法,不能创建对象
能够说出多态的前提//有子父类继承关系|有类和接口的实现关系(有爹)
能够写出多态的格式//父类的类型 变量名 = new 子类对象();Animal a = new Cat();Animal a = new Dog();Fu fu = new Zi();//接口的类型 变量名 = new 实现类对象();MyInter f = new MyInterImpl();
能够理解多态向上转型和向下转型//1.向上转型:多态本身就是向上转型格式:父类的类型 变量名 = new 子类对象();接口的类型 变量名 = new 实现类对象();Animal a = new Cat();a = new Dog();好处:扩展性强,可以赋值不同的子类对象,调用不同子类重写的方法弊端:无法使用子类特有的成员变量和成员方法//2.向下转型:前提必须是多态,可以把父类的类型强制转换为子类类型(强转)格式:子类类型 变量名 = (子类类型)父类变量名;Cat c = (Cat)a;c.catchMouse();好处:可以使用子类特有的内容

一.final关键字

1.修饰类

package com.itheima.demo01finalClass;/*final关键字:最终final修饰的类:是一个最终类,不能被继承(太监类)final修饰的类:其他的使用方式不变*/
public final class Fu{
}

package com.itheima.demo01finalClass;//Cannot inherit from final 'com.itheima.demo01finalClass.Fu'
/*public class Zi extends Fu{
}*/

查询API发现像 public final class String 、public final class Math 、public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

2.修饰方法

package com.itheima.demo02finalMethod;/*final修饰的方法:是一个最终方法,可以被继承使用,但是不能被子类重写*/
public class Fu {public void show01(){System.out.println("Fu类的show01方法!");}public final void show02(){System.out.println("Fu类被fianl修饰的show02方法!");}
}

package com.itheima.demo02finalMethod;public class Zi extends Fu {@Overridepublic void show01() {System.out.println("Zi类重写Fu类的show01方法!");}/*'show02()' cannot override 'show02()' ... overridden method is final*//*public void show02(){System.out.println("Fu类被fianl修饰的show02方法!");}*/
}

package com.itheima.demo02finalMethod;public class Demo01 {public static void main(String[] args) {Zi zi = new Zi();zi.show01();//Zi类重写Fu类的show01方法!zi.show02();//Fu类被fianl修饰的show02方法!}
}

3.修饰变量

局部变量

package com.itheima.demo03finalvariable;/*final修饰的变量:是一个常量,值不能改变一次赋值,终身不变*/
public class Demo01 {public static void main(String[] args) {/*定义在方法中的变量:局部变量==>唯一可以使用的修饰符就是fianl*///基本数据类型:值不能改变final int a = 10;//a=20;//Cannot assign a value to final variable 'a' 不能给final修饰的变量a赋值//引用数据类型:地址值不能改变(不能在重新创建对象赋值)final Student s = new Student("张三",18);//System.out.println(s);//Student@140e19d//s = new Student("李四",20);//Cannot assign a value to final variable 's' 不能给final修饰的变量s赋值//System.out.println(s);//Student@17327b6//对象中的属性可以改变s.setName("李四");s.setAge(20);System.out.println(s.getName()+"\t"+s.getAge());}
}

package com.itheima.demo03finalvariable;public class Student {private String name;private int age;public Student() {}public Student(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;}
}

成员变量

package com.itheima.demo03finalvariable;/*final修饰的成员变量(了解):成员变量:定义在类中方法外的变量特点:必须在创建对象前赋值,只能赋值一次注意:成员变量的默认初始化值,不能作为fianl修饰的变量的值,必须手动给变量赋值    赋值方式:1.定义变量的同时,直接赋值    2.在构造方法中给最终变量赋值(构造方法是在创建对象前执行)3.使用构造代码块赋值(后边讲)无论使用那种赋值方式,fianl修饰的变量只能赋值一次*/
public class Person {//成员变量的默认初始化值,不能作为fianl修饰的变量的值,必须手动给变量赋值//final int a;//Variable 'a' might not have been initialized//1.定义变量的同时,直接赋值final int b = 20;final int c;public Person() {//2.在构造方法中给最终变量赋值(构造方法是在创建对象前执行)c=30;//无论使用那种赋值方式,fianl修饰的变量只能赋值一次//b=200;//Cannot assign a value to final variable 'b'//c=300;//Variable 'c' might already have been assigned to}
}

被final修饰的常量名称，一般都有书写规范，所有字母都大写。

4.练习

package com.itheima.demo04Test;/*需求:在商场案例中,所有的工作人员都属于同一个公司,所以我想要在工作人员类型中定义属性:  所属公司(company)要求：所属公司一旦定义不允许随意更改！*/
public class Worker {public final String company = "传智播客-昌平校区";public final String address = "北京市昌平区金燕龙办公楼";public final String web = "www.itheima.com";
}

package com.itheima.demo04Test;public class Demo01 {public static void main(String[] args) {Worker w = new Worker();System.out.println(w.company);System.out.println(w.address);System.out.println(w.web);//Cannot assign a value to final variable 'web'//w.web = "www.itcast.cn";}
}

5.总结

final关键字可以修饰哪些地方？
可以修饰类、方法、变量

final 修饰的特点
修饰类：表明该类是最终类，不能被继承
修饰方法：表明该方法是最终方法，不能被重写
修饰变量：表明该变量是常量，不能再次被赋值

二.static关键字

1.static关键字概述(了解)

在实际工作中:

​ 每个人不同的属性定义为非静态的:姓名,年龄,身份证,手机号…

​ 每个人相同的属性定义为静态的:国家(静态==>被共享==>静态区)

2.static关键字的使用(使用)

package com.itheima.demo05static;/*定义非静态成员:姓名,年龄定义静态成员:国家*/
public class Student {String name;int age;static String country = "中国";public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}
}

package com.itheima.demo05static;public class Demo01Student {public static void main(String[] args) {//创建Student对象Student s1 = new Student("张三",18);System.out.println(s1.name);//张三System.out.println(s1.age);//18System.out.println(s1.country);//中国Student s2 = new Student("李四",19);System.out.println(s2.name);//李四System.out.println(s2.age);//19System.out.println(s2.country);//中国s2.country = "中华人民共和国";System.out.println(s2.country);//中华人民共和国//静态成员被所有的对象所共享使用,一个对象修改了静态成员的值,其他的对象在使用就是修改后的System.out.println(s1.country);//中华人民共和国}
}

3.static修饰的静态成员的使用方式(重点)

package com.itheima.demo06static;/*static修饰的静态成员的使用方式(重点)定义每个学生私有的属性(非静态):只有一种使用方式:创建对象使用定义每个学生共享的属性(静态):有两种使用方式:1.创建对象使用(不推荐,只要创建对象,在堆内存中就会有一个对象,占用内存)2.静态的成员属于类,所以可以通过类名直接使用,无需创建对象(重点)类名.静态成员变量类名.静态成员方法();*/
public class Student {//定义非静态成员变量int a = 10;//定义静态成员变量static int b  = 20;//定义非静态的成员方法public void show01(){System.out.println("Student类中的非静态成员方法show01!");}//定义静态的成员方法public static void show02(){System.out.println("Student类中的静态成员方法show02!");}
}

package com.itheima.demo06static;public class Demo01 {public static void main(String[] args) {//非静态成员只能创建对象使用Student s = new Student();System.out.println(s.a);s.show01();//静态成员即可以创建对象使用(不推荐)System.out.println(s.b);s.show02();//静态成员也可以通过类名直接使用(推荐)System.out.println(Student.b);Student.show02();System.out.println("------------------------");//同一个类中,使用非静态的方法,也只能创建对象调用Demo01 demo01 = new Demo01();demo01.print();System.out.println("------------------------");//同一个类中,静态方法,使用类名调用Demo01.print2();//同一个类中,调用静态方法,可以省略类名print2();}public void print(){System.out.println("Hello");}public static void print2(){System.out.println("Hello");}
}

4.static练习

package com.itheima.demo07staticTest;/*需求：系统中 Student 和 Teacher类，都有一个show()方法，方法中输出学校地址的信息。 两个对象的地址是完全一样的，需要考虑节省内存问题。Student打印：我的学校是：传智播客-顺义校区Teacher打印：我的单位是：传智播客-顺义校区实现思路：“传智播客-顺义校区”单独定义一个类School ，里面定义变量address ，可以被多个对象“共享”。*/
public class Student {public void show(){System.out.println("我的学校是："+School.address);}
}

package com.itheima.demo07staticTest;public class Teacher {public void show(){System.out.println("我的单位是："+School.address);}
}

package com.itheima.demo07staticTest;public class School {public static String address = "传智播客-昌平校区";
}

package com.itheima.demo07staticTest;public class Demo01 {public static void main(String[] args) {Teacher t = new Teacher();t.show();//匿名对象new Student().show();}
}

5.static的问题

1、static可以修饰哪些成员？成员变量,成员方法
2、static是否可以修饰成员变量？ 是
static是否可以修饰局部变量？否
3、static是否可以修饰“类”（除内部类）？否
4、被static修饰的成员如何访问？类名.成员变量,类名.成员方法

6.static的特点

• 静态成员优先于非静态成员加载到内存中
• 静态成员:先进入到方法区的静态区中
• 非静态成员:创建对象之后才会进入到堆内存中
• 如果一个类中既有“静态成员”，也有“普通成员”：
• “静态成员”只能访问本类的“静态成员”，不能访问普通成员！
• “普通成员”既能访问本类的“静态成员”，也能访问“普通成员”！

三.接口

1.接口概述(了解)

接口是一个额外的功能,实现接口就具备该功能,不实现就不具备

接口:是引用数据类型的一种,是功能的集合(接口中一般定义的都是方法)接口中不能定义变量,只能定义常量(很少使用)
定义接口使用也是.java文件;编译生成.class文件
定义接口使用关键字 interface
定义格式:修饰符 interface 接口名{抽象方法;(JDK7) 重点默认方法;(JDK8)    静态方法;(JDK8)常量(很少使用)}

2.定义使用含有抽象方法的接口(重点)

package com.itheima.demo09abstractInterface;/*定义使用含有抽象方法的接口(重点)抽象方法的定义格式:修饰符 abstract 返回值类型 方法名(参数列表);注意:[接口中]的抽象方法的修饰符固定就是public abstract,可以省略不写,也可以写一部分建议全部写出,提高阅读性public abstract 返回值类型 方法名(参数列表);public  返回值类型 方法名(参数列表);abstract 返回值类型 方法名(参数列表);返回值类型 方法名(参数列表);接口的使用:1.接口和抽象类一样,也无法创建对象使用2.可以定义一个实现类,实现接口,重写接口中所有的抽象方法,创建实现类对象使用*/
public interface MyInter {//定义抽象方法//public abstract void show01();//abstract void show01();//public void show01();void show01();public abstract void show02(int a);public abstract String show03(double b);
}

package com.itheima.demo09abstractInterface;/*可以定义一个实现类,实现接口,重写接口中所有的抽象方法,创建实现类对象使用实现类:类似于继承(类实现接口之后,也会继承接口中所有的方法)实现使用关键字:implements格式:public class 实现类名 implements 接口{重写接口中所有的抽象方法;}工作中实现类名书写规范:接口名Impl==>见名知意*/
public class MyInterImpl implements MyInter{@Overridepublic void show01() {System.out.println("实现类重写了接口中的show01方法");}@Overridepublic void show02(int a) {System.out.println("实现类重写了接口中的show02方法"+a);}@Overridepublic String show03(double b) {System.out.println("实现类重写了接口中的show03方法"+b);return "你好";}
}

package com.itheima.demo09abstractInterface;public class Demo01 {public static void main(String[] args) {//接口和抽象类一样,也无法创建对象使用//'MyInter' is abstract; cannot be instantiated//MyInter my = new MyInter();//创建接口的实现类对象MyInterImpl my = new MyInterImpl();my.show01();my.show02(100);String s = my.show03(1.1);System.out.println(s);//你好}
}

3.定义使用含有默认方法的接口(了解)

package com.itheima.demo10defaultInterface;/*定义使用含有默认方法的接口(了解)默认方法定义格式:修饰符 default 返回值类型 方法名(形式参数列表){方法体;}注意:默认方法的关键字default不能省略的*/
public interface MyInter {//定义默认方法public default void show01(){System.out.println("MyInter接口中的默认show01方法!");}public default void show02(){System.out.println("MyInter接口中的默认show02方法!");}
}

package com.itheima.demo10defaultInterface;/*实现类实现接口:可以选择性的重写默认方法实现类没有重写默认方法,使用继承自接口的默认方法实现类重写了默认方法,使用重写后的方法注意:实现类重写默认方法,去掉default关键字重写方法的快捷键:ctrl+o*/
public class MyInterImpl implements MyInter{@Overridepublic  void show01() {System.out.println("实现类重写MyInter接口中的默认show01方法!");}
}

package com.itheima.demo10defaultInterface;public class Demo01 {public static void main(String[] args) {//创建接口的实现类对象MyInterImpl my = new MyInterImpl();my.show01();//实现类重写MyInter接口中的默认show01方法!my.show02();//MyInter接口中的默认show02方法!}
}

4.定义使用含有静态方法的接口(了解)

package com.itheima.demo11staticInterface;/*定义使用含有静态方法的接口(了解)静态方法定义格式:修饰符 static 返回值类型 方法名(形式参数列表){方法体;}注意:静态方法的关键字static不能省略的*/
public interface MyInter {//定义静态方法public static void show01(){System.out.println("MyInter接口中的静态show01方法!");}public static void show02(){System.out.println("MyInter接口中的静态show02方法!");}
}

package com.itheima.demo11staticInterface;/*含有静态方法的接口,静态方法属于接口本身,可以通过接口名,直接使用实现类即不能继承静态方法,也不能重写静态方法(废物类)*/
public class MyInterImpl implements MyInter{//Method does not override method from its superclass/*@Overridepublic static void show01(){System.out.println("MyInter接口中的静态show01方法!");}*/
}

package com.itheima.demo11staticInterface;public class Demo01 {public static void main(String[] args) {//MyInterImpl my = new MyInterImpl();//Static method may be invoked on containing interface class only 接口中的静态方法不能继承//my.show01();//通过接口名,直接使用静态方法MyInter.show01();MyInter.show02();}
}

注意:

​ 接口中的静态方法不能继承使用,也不能重写

​ 类中的静态方法可以继承使用,不能重写

5.类继承类的同时实现多个接口(重点)

package com.itheima.demo12classAndInterface;public abstract class QinDie {public abstract void kaoQingHua();public void work(){System.out.println("亲爹希望儿子找到一份好工作!");}
}

package com.itheima.demo12classAndInterface;public interface GanDie1 {public abstract void kaoQingHua();public abstract void findGF();
}

package com.itheima.demo12classAndInterface;public interface GanDie2 {public abstract void kaoBeiDa();public default void work(){System.out.println("GanDie2希望儿子找到一份好工作!");}
}

package com.itheima.demo12classAndInterface;/*类继承类的同时实现多个接口(重点)一个人只能有一个亲爹(父类),但是可以有多个干爹(接口)格式:public class 子类 extends 父类 implements 接口1,接口2,...{重写父类和接口中所有的抽象方法选择性的重写父类的普通方法|接口中的默认方法}注意:父类的普通方法和接口的默认方法相同,子类使用父类的方法*/
public class Zi extends QinDie implements GanDie1,GanDie2{@Overridepublic void findGF() {System.out.println("子类重写GanDie1接口中的findGF方法!");}@Overridepublic void kaoBeiDa() {System.out.println("子类重写GanDie2接口中的kaoBeiDa方法!");}@Overridepublic void kaoQingHua() {System.out.println("子类重写QinDie和GanDie1接口中的kaoQingHua方法!");}
}

package com.itheima.demo12classAndInterface;public class Demo01 {public static void main(String[] args) {//创建Zi类对象Zi zi = new Zi();zi.kaoBeiDa();zi.kaoQingHua();zi.findGF();zi.work();}
}

6.接口的多继承(重点)

接口与接口之间:继承关系

package com.itheima.demo13interface;public interface A {public abstract void a();public abstract void show();public default void show01(){System.out.println("A接口的默认show01方法");}public default void show02(){System.out.println("A接口的默认show02方法");}
}

package com.itheima.demo13interface;public interface B {public abstract void b();public abstract void show();public default void show02(){System.out.println("B接口的默认show02方法");}
}

package com.itheima.demo13interface;/*1.类与类之间:继承关系(单继承)public class 子类 extends 父类{ }2.类与接口之间:实现关系(多实现)public class 实现类 implements 接口1,接口2,接口3...{}3.接口与接口之间:继承关系(多继承)public interface 子接口 extends 父接口1,父接口2...{}注意:多个父接口中有相同的默认方法,子接口必须重写默认方法,使用子接口自己重写后的不重写相同的默认方法,有不确定性,不确定使用哪个父接口的*/
public interface C extends A,B{@Overridepublic default void show02() {System.out.println("C接口重写A接口和B接口重复的show02方法!");}
}

package com.itheima.demo13interface;/*使用实现类实现了C接口,相当于同时实现了ABC三个接口需要重写三个接口中所有的抽象方法*/
public class ABCImpl implements C{@Overridepublic void a() {System.out.println("实现类重写了A接口中的a方法");}@Overridepublic void b() {System.out.println("实现类重写了B接口中的b方法");}@Overridepublic void show() {System.out.println("实现类重写了A接口和B接口中的show方法");}
}

package com.itheima.demo13interface;public class Demo01 {public static void main(String[] args) {ABCImpl abc = new ABCImpl();abc.a();//实现类重写了A接口中的a方法abc.b();//实现类重写了B接口中的b方法abc.show();//实现类重写了A接口和B接口中的show方法abc.show01();//A接口的默认show01方法abc.show02();//C接口重写A接口和B接口重复的show02方法!}
}

7.接口中其他成员的特点(使用)

1.接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，
接口中常量默认使用public static final修饰

​ 接口中的常量修饰符可以省略不写.不写默认也是public static final
​ 常量的命名规则:所有的单词都要大写,多个单词之间可以使用下划线连接
​ AAA_BBB_CCC
​ 定义一些常用的常量:
​ 公司的名称:“江苏省传智播客股份有限公司北京分公司”
​ 公司的网址: “www.itcast.cn” “www.itheima.com”
​ 公司的地址: 北京市顺义区京顺路99号黑马程序员
2.接口中，没有构造方法，不能创建对象。
3.接口中，没有静态代码块(后面讲)

package com.itheima.demo14interface;/*接口中其他成员的特点(使用)定义一些常用的常量:公司的名称:"江苏省传智播客股份有限公司北京分公司"公司的网址: "www.itcast.cn"  "www.itheima.com"公司的地址: 北京市昌平区金燕龙办公楼黑马程序员*/
public interface MyInter {public static final String NAME = "江苏省传智播客股份有限公司北京分公司";public static final String WEB = "www.itheima.com";String ADDRESS = "北京市昌平区金燕龙办公楼黑马程序员";
}

package com.itheima.demo14interface;public class Demo01 {public static void main(String[] args) {//接口中的常量,通过接口名可以直接使用System.out.println(MyInter.NAME);System.out.println(MyInter.WEB);System.out.println(MyInter.ADDRESS);//Cannot assign a value to final variable 'WEB' 常量的值不能改变//MyInter.WEB = "www.itcast.cn";System.out.println(Math.PI);}
}

8.接口和抽象类的区别(重点)

package com.itheima.demo15test;//缉毒接口
public interface JiDu {//缉毒方法public abstract void jiDu();
}

package com.itheima.demo15test;//牧羊接口
public interface MuYang {//牧羊方法public abstract void muYang();
}

package com.itheima.demo15test;/*定义犬科类:是根据子类共性抽取形成*/
public abstract class Quan {//姓名private String name;//年龄private int age;//吼叫方法public abstract void huJiao();//吃饭方法public abstract void eat();//睡觉方法public abstract void sleep();public Quan() {}public Quan(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;}
}

package com.itheima.demo15test;/*哈士奇类:是犬的一种,所以继承犬类*/
public class HaShiQi extends Quan{public HaShiQi() {}public HaShiQi(String name, int age) {super(name, age);}@Overridepublic void huJiao() {System.out.println("二哈在哈哈的叫唤!");}@Overridepublic void eat() {System.out.println("二哈在吃狗粮!");}@Overridepublic void sleep() {System.out.println("二哈在四脚朝天的睡觉!");}
}

package com.itheima.demo15test;/*牧羊犬类:是犬的一种,所以继承犬类具备缉毒功能,实现缉毒接口具备牧羊功能,实现牧羊接口*/
public class MuYangQuan extends Quan implements JiDu,MuYang{public MuYangQuan() {}public MuYangQuan(String name, int age) {super(name, age);}@Overridepublic void huJiao() {System.out.println("名字叫"+getName()+"年龄为:"+getAge()+"的牧羊犬在嗷嗷的叫唤!");}@Overridepublic void eat() {System.out.println("名字叫"+getName()+"年龄为:"+getAge()+"的牧羊犬在吃羊!");}@Overridepublic void sleep() {System.out.println("名字叫"+getName()+"年龄为:"+getAge()+"的牧羊犬在羊圈睡觉!");}@Overridepublic void jiDu() {System.out.println("名字叫"+getName()+"年龄为:"+getAge()+"的牧羊犬在帮助警察缉毒!");}@Overridepublic void muYang() {System.out.println("名字叫"+getName()+"年龄为:"+getAge()+"的牧羊犬在和羊一起玩耍!");}
}

package com.itheima.demo15test;/*缉毒犬类:是犬的一种,所以继承犬类具备缉毒功能,实现缉毒接口*/
public class JiDuQuan extends Quan implements JiDu{public JiDuQuan() {}public JiDuQuan(String name, int age) {super(name, age);}@Overridepublic void huJiao() {System.out.println("缉毒犬在嗷嗷的叫唤!");}@Overridepublic void eat() {System.out.println("缉毒犬在吃皇家狗粮!");}@Overridepublic void sleep() {System.out.println("缉毒犬在站着睡!");}@Overridepublic void jiDu() {System.out.println("缉毒犬在缉毒!");}
}

package com.itheima.demo15test;public class Demo01 {public static void main(String[] args) {//创建哈士奇对象HaShiQi hsq = new HaShiQi();hsq.eat();hsq.huJiao();hsq.sleep();//创建缉毒犬对象JiDuQuan jdq = new JiDuQuan();jdq.eat();jdq.huJiao();jdq.sleep();jdq.jiDu();//创建牧羊犬对象MuYangQuan myq = new MuYangQuan("阿烈",5);myq.eat();myq.huJiao();myq.sleep();myq.jiDu();myq.muYang();}
}

9.练习一

​ 1.“超市管理系统”，设计三个类：收银员(Cashier)、销售员(Sales)、会计(Accountant)，要求：
​ 1). 三类人员都需要有“工作(work)”，而且每个类必须要有自己的工作内容。
​ 2). 收银员(Cashier)、会计(Accountant)都要有“统计(count)”的功能，而且两个类也必须要有自己统计的方式
​ 请设计以上的类结构，并编写测试类。

10.练习二

​ 2.为某“体育学院”设计一个系统，需要记录：足球运动员、乒乓球运动员、足球教练员、乒乓球教练员：
​ 1). 所有人员都要有：属性：姓名、年龄；方法：吃饭(运动员吃营养餐，教练员吃工作餐)
​ 2). 由于经常有外国友人来学校交流乒乓球技术，所以要求“乒乓球”相关人员都要有“说英语”的功能
​ 请设计以上的类结构，并编写测试类。

11.接口总结

定义和实现接口的关键字是什么？ interface  implements
接口的作用？弥补了Java单继承的弊端，子类可以同时实现一个/多个接口，进行功能扩展。
接口有哪些特性？（说出3个）1.不能创建对象 (没有构造方法)2.实现类实现接口,创建实现类对象使用 3.接口中不能定义变量,只能定义常量(public static final)4.接口中可以定义抽象,默认,静态方法 5.接口支持多继承,一个接口可以继承多个接口
接口中的成员？public interface 接口名{//1.公有、静态、常量//2.公有、抽象方法(重点)//3.公有、默认方法//4.公有、静态方法}
类和接口的关系小结？
类和类：继承关系，使用extends，只能“单继承”；
类和接口：实现关系，使用implements，可以“多实现”；
接口和接口：继承关系，使用extends，可以“多继承”；

四.多态(重点)

1.多态概述

多态:父类的引用变量指向了子类的对象

2.多态的代码实现

定义父类

package com.itheima.demo16duotai;public class Fu {public void show(){System.out.println("Fu类的show方法!");}
}

定义子类

package com.itheima.demo16duotai;public class Zi extends Fu {public void show(){System.out.println("Zi类重写Fu类的show方法!");}
}

定义抽象父类

package com.itheima.demo16duotai;public abstract class Animal {public abstract void eat();
}

定义子类

package com.itheima.demo16duotai;public class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫吃猫粮!");}
}

package com.itheima.demo16duotai;public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃狗粮!");}
}

定义接口

package com.itheima.demo16duotai;public interface MyInter {public abstract void my();
}

定义接口的实现类

package com.itheima.demo16duotai;public class MyInterImpl implements MyInter {@Overridepublic void my() {System.out.println("实现类重写了MyInter接口中的my方法!");}
}

定义测试类

package com.itheima.demo16duotai;/*多态:父类的引用变量指向了子类的对象格式:父类类型 变量名 = new 子类对象();接口类型 变量名 = new 实现类对象();多态的使用前提:必须有爹必须有子父类的继承关系接口和实现类的实现关系注意:1.多态调用的是子类重新后的方法2.如果有多个子类,创建的是哪个子类对象,调用的就是哪个子类重写后的方法*/
public class Demo01 {public static void main(String[] args) {//普通子父类的多态 父类:Fu  子类:ZiFu fu = new Zi();fu.show();//Zi类重写Fu类的show方法!//抽象子父类的多态 父类:Animal 子类:Cat,DogAnimal a = new Cat();a.eat();//猫吃猫粮!a = new Dog();a.eat();//狗吃狗粮!//接口和实现类的多态  接口(父类):MyInter 实现类(子类):MyInterImplMyInter m = new MyInterImpl();m.my();//实现类重写了MyInter接口中的my方法!}
}

3.多态的好处和弊端

package com.itheima.demo02duotai;public abstract class Animal {public abstract void eat();public abstract void sleep();
}

package com.itheima.demo02duotai;public class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃鱼!");}@Overridepublic void sleep() {System.out.println("猫随心所欲的睡!");}//定义猫特有的抓老鼠的方法public void catchMouse(){System.out.println("猫和老鼠一起玩耍!");}
}

package com.itheima.demo02duotai;public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃肉!");}@Overridepublic void sleep() {System.out.println("狗趴着睡!");}//定义狗特有的看家的方法public void lookHome(){System.out.println("狗狗在看家!");}
}

package com.itheima.demo17duotai;import com.itheima.demo13interface.C;/*多态的好处:扩展性强父类的变量可以赋值不同的子类对象赋值哪个子类对象,调用的就是哪个子类对象重写后的方法多态的弊端:不能使用子类特有的功能多态表现的是父类的形态(父类类型的变量),父类中没有子类特有的方法实际工作中:一般都是使用父类类型作为方法的形式参数类型或者方法的返回值类型*/
public class Demo01 {public static void main(String[] args) {Cat c = new Cat();c.eat();c.sleep();c.catchMouse();Animal a = new Cat();a.eat();a.sleep();//a.catchMouse();//不能使用子类特有的功能System.out.println("----------------------------------------------------");show(new Cat());show(new Dog());System.out.println("----------------------------------------------------");/*多态:Animal an = getInstance(); = new Cat();Animal an = getInstance(); = new Dog();*/Animal an = getInstance();an.eat();an.sleep();}/*定义一个方法,方法的返回值类型使用Animal类型在方法中可以返回Animal的任意的子类对象*/public static Animal getInstance(){//return new Cat();return new Dog();}/*定义一个show方法,参数使用Animal类型,可以接收Animal任意的子类对象多态:扩展性强Animal a = new Cat();Animal a = new Dog()*/public static void show(Animal a){a.eat();a.sleep();}/*定义一个show方法,参数使用Dog类型,在方法中可以调用Dog类中的方法Dog dog = new Dog()*//*public static void show(Dog dog){dog.eat();dog.sleep();dog.lookHome();}*//*定义一个show方法,参数使用Cat类型,在方法中可以调用Cat类中的方法Cat cat = new Cat();*//*public static void show(Cat cat){cat.eat();cat.sleep();cat.catchMouse();}*/
}

4.多态的转型(向上转型和向下转型)

package com.itheima.demo18duotai;public class Fu {public void work(){System.out.println("父亲在工作!");}
}

package com.itheima.demo18duotai;public class Zi extends Fu {public void work(){System.out.println("儿子在工作!");}//定义子类特有的玩游戏的方法public void palyGame(){System.out.println("儿子在玩游戏!");}
}

package com.itheima.demo18duotai;import com.itheima.demo13interface.C;
import com.itheima.demo17duotai.Animal;
import com.itheima.demo17duotai.Cat;
import com.itheima.demo17duotai.Dog;/*多态的转型:1.向上转型:多态本身就是向上转型,把子类对象赋值给父类变量格式:父类类型 变量名 = new 子类对象();double d = 10;好处:扩展性强:可以赋值不同的子类对象,调用不同子类重写后的方法2.向下转型:把父类类型的变量强制转换为子类类型前提:必须有多态格式:子类类型 变量名 = (子类类型)父类变量名;int a = (int)8.8;好处:转换为子类类型之后,就可以使用子类特有的功能*/
public class Demo01 {public static void main(String[] args) {//1.向上转型:多态本身就是向上转型,把子类对象赋值给父类变量//父亲病了,儿子化妆为父亲,替父亲工作Fu fu = new Zi();fu.work();//儿子在工作!//儿子替父亲工作完毕,想玩游戏,化妆为父亲,父亲没有玩游戏的方法//fu.playGame();//Cannot resolve method 'playGame()'//2.向下转型:把父类类型的变量强制转换为子类类型(强转)//儿子卸妆,变化儿子的形态Zi zi = (Zi)fu;zi.palyGame();//儿子在玩游戏!System.out.println("======================================");//向下转型的前提必须是多态Fu f2 = new Fu();//ClassCastException: com.itheima.demo18duotai.Fu cannot be cast to com.itheima.demo18duotai.Zi//Zi z2 = (Zi)f2;//类型转换异常:Fu类型不能转换为ZiSystem.out.println("======================================");Animal a = new Cat();//向上转型Cat c = (Cat)a;//向下转型c.catchMouse();//ClassCastException: com.itheima.demo17duotai.Cat cannot be cast to com.itheima.demo17duotai.Dog//Dog d = (Dog)a;//类型转换异常:猫不能转换为狗的类型}
}

5.instanceof关键字

package com.itheima.demo19instanceof;import com.itheima.demo17duotai.Animal;
import com.itheima.demo17duotai.Cat;
import com.itheima.demo17duotai.Dog;import java.util.Random;/*instanceof关键字ClassCastException: com.itheima.demo17duotai.Fu cannot be cast to com.itheima.demo17duotai.Zi作用:判断某个对象是否属于某种数据类型向下转型的时候容易引发ClassCastException类型转换异常,可以在向下转型之前,先进行判断,是对应的类型,在向下转型格式:boolean b = 对象名 instanceof 数据类型;true: 对象是对应的数据类型false: 对象不是对应的数据类型注意:要判断的对象和数据类型之间必须有继承或者实现关系*/
public class Demo01 {public static void main(String[] args) {Animal a = new Cat();boolean b1 = a instanceof Cat;System.out.println("b1:"+b1);//b1:trueboolean b2 = a instanceof Dog;System.out.println("b2:"+b2);//b2:false//在向下转型之前,就可以增加一个判断:是对应的类型在强转if(a instanceof Cat){Cat c = (Cat)a;c.eat();c.sleep();c.catchMouse();}if(a instanceof Dog){Dog d = (Dog)a;d.eat();d.sleep();d.lookHome();}//要判断的对象和数据类型之间必须有继承或者实现关系Random r = new Random();//boolean b3 = r instanceof Cat;//编译报错 Random和Cat没有继承和实现关系}
}

🎗经验分享

1.已知代码

/*** 动物类*/
public class Animal {public void sleep(){System.out.println("Animal....Sleep....");}public void eat(){System.out.println("Animal....eat....");}
}
/*** 狗类*/
public class Dog{public void sleep() {System.out.println("Dog....Sleep....");}public void eat(){System.out.println("Dog....eat....");}
}
/*** 测试类*/
public class TestDemo {public static void main(String[] args) {//1.创建对象Animal an = new Dog();//2.调用方法an.sleep();an.eat();}
}

2.出现的问题

编译时报错了,错误信息如下:

3.问题的分析

根据代码的报错位置,是多态创建时出错了!

我们回顾一下多态的提前:必须有继承或者实现

很明显,我们的Dog类并没有继承Animal,不是Animal的子类

4.问题解决办法

在Dog类中继承Animal即可

public class Dog extends Animal{public void sleep() {System.out.println("Dog....eat....");}public void eat(){System.out.println("Dog....eat....");}
}

6.综合案例1-汽车销售公司类结构设计

package com.itheima.demo20Test;//定义GPS接口
public interface IGPS{//定义使用GPS的方法public abstract void useGPS();
}

package com.itheima.demo20Test;/*父类Car:根据子类共性抽取形成*/
public abstract class Car {//品牌private String type;//型号private String brand;//颜色private String color;//价格private double price;//定义抽象的run方法public abstract void run();public Car() {}public Car(String type, String brand, String color, double price) {this.type = type;this.brand = brand;this.color = color;this.price = price;}public String getType() {return type;}public void setType(String type) {this.type = type;}public String getBrand() {return brand;}public void setBrand(String brand) {this.brand = brand;}public String getColor() {return color;}public void setColor(String color) {this.color = color;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}
}

package com.itheima.demo20Test;/*定义奔驰轿车类,是汽车Car一种,所以继承Car类*/
public class BanZCars extends  Car{@Overridepublic void run() {System.out.println("奔驰轿车最高运行时速：200公里");}
}

package com.itheima.demo20Test;/*定义奔驰SUV类,是汽车Car一种,所以继承Car类*/
public class BanZSUV extends  Car{@Overridepublic void run() {System.out.println("奔驰SUV最高运行时速：190公里");}
}

package com.itheima.demo20Test;/*定义宝马轿车类,是汽车Car一种,所以继承Car类宝马轿车有GPS功能,实现IGPS接口*/
public class BMWCars extends  Car implements IGPS{@Overridepublic void run() {System.out.println("宝马轿车最高运行时速：230公里");}@Overridepublic void useGPS() {System.out.println("宝马轿车可以使用GPS功能!");}
}

package com.itheima.demo20Test;/*定义宝马SUV类,是汽车Car一种,所以继承Car类宝马SUV有GPS功能,实现IGPS接口*/
public class BMWSUV extends  Car implements IGPS{@Overridepublic void run() {System.out.println("宝马SUV最高运行时速：220公里");}@Overridepublic void useGPS() {System.out.println("宝马SUV可以使用GPS功能!");}
}

package com.itheima.demo20Test;/*定义销售员类*/
public class Sales {/*定义销售方法(sell(...)),可以销售任意类型的车多态:方法的参数使用父类类型,可以接收Car任意的子类对象Car car = new BanZCars();Car car = new BanZSUV()Car car = new BMWCars()Car car = new BMWSUV()*/public void sell(Car car){car.run();//扩展:判断车实现类IGPS接口,调用使用GPS功能if( car instanceof BMWCars){BMWCars b1 = (BMWCars)car;b1.useGPS();}if( car instanceof BMWSUV){BMWSUV b2 = (BMWSUV)car;b2.useGPS();}}
}

package com.itheima.demo20Test;/*综合案例1：汽车销售公司类结构设计1.目前公司销售以下几种车：奔驰轿车(BanzCars)、宝马轿车(BMWCars)、奔驰SUV(BanzSuv)、宝马SUV(BMWSuv)2.所有的车辆都要记录以下信息：属性：品牌、型号、颜色、价格方法：运行(run)奔驰轿车最高运行时速：200公里宝马轿车最高运行时速：230公里奔驰SUV最高运行时速：190公里宝马SUV最高运行时速：220公里3.宝马车的所有车系都有”GPS”功能。4.公司有销售员，可以销售任何车型：(注：定义销售员类(Sales)，定义销售方法(sell(...))，参数是?)  sell(Car car){ car.run();}系统中既有父类又有接口,先定义接口,在定义父类,在定义子类|实现类*/
public class Demo01Test {public static void main(String[] args) {//定义销售员类Sales s = new Sales();s.sell(new BanZCars());s.sell(new BanZSUV());s.sell(new BMWCars());s.sell(new BMWSUV());}
}

7.综合案例2-票务管理系统类结构设计

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！