目录
第一章 集合
集合，集合是java中提供的一种容器，可以用来存储多个数据。 在前面的学习中，我们知道数据多了，可以使用数组存放或者使用ArrayList集合进行存放数据。那么，集合和数组既然都是容器，它们有啥区别呢？数组的长度是固定的。集合的长度是可变的。集合中存储的元素必须是引用类型数据 。
1.1 ArrayList集合
Alt+Shift+s：给私有成员变量添加get与set方法(或者右键sourse)。
ArrayList集合举例：
package day18.demo1;
public class Person {
private String name;
private int 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;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person() {
super();
// TODO Auto-generated constructor stub
}
}package day18.demo1;
import java.util.ArrayList;
/*
* 集合体系,
* 目标 集合本身是一个存储的容器:
* 必须使用集合存储对象
* 遍历集合,取出对象
* 集合自己的特性
*/
public class ArrayListDemo {
public static void main(String[] args) {
/*
* 集合ArrayList,存储int类型数
* 集合本身不接受基本类,自动装箱存储
*/
ArrayList<Integer> array = new ArrayList<Integer>();
array.add(11);
array.add(12);
array.add(13);
array.add(14);
array.add(15);
for(int i = 0 ; i < array.size() ;i++){
System.out.println(array.get(i));
}
/*
* 集合存储自定义的Person类的对象
*/
ArrayList<Person> arrayPer = new ArrayList<Person>();
arrayPer.add(new Person("a",20));
arrayPer.add(new Person("b",18));
arrayPer.add(new Person("c",22));
for(int i = 0 ; i < arrayPer.size();i++){
//get(0),取出的对象Person对象
//打印的是一个对象,必须调用的toString()
System.out.println(arrayPer.get(i));//输出的不是地址，因为Person类中重写了toString类
}
}
}
1.2 集合Collection
查看ArrayList类发现它继承了抽象类AbstractList同时实现接口List，而List接口又继承了Collection接口。Collection接口为最顶层集合接口了。
说明我们在使用ArrayList类时，该类已经把所有抽象方法进行了重写。那么，实现Collection接口的所有子类都会进行方法重写。
- Collecton接口常用的子接口有：List接口、Set接口
- List接口常用的子类有：ArrayList类、LinkedList类
- Set接口常用的子类有：HashSet类、LinkedHashSet类
List：可以存储重复的元素，并且容器中元素都有序排列。
Set：不可存储重复的元素，并且容器中元素无序。
1.3 集合Collection的方法
集合转数组的意义：在IO中统计文件个数，一旦数目确定了就会将集合转为数组。
多行注释：
CTRL + SHIFT + /
多行取消注释（斜杠换成反斜杠）：
CTRL + SHIFT + \
1.3.1 add()方法
Collection<String> coll = new ArrayList<String>();
coll.add("abc");1.3.2 clear方法
void clear() 清空集合中的所有元素，集合容器本身依然存在。//[]
public static void function(){
//接口多态的方式调用
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("bcd");
System.out.println(coll);
coll.clear();
System.out.println(coll);//[] 只是倒掉水，杯子还在
}1.3.3 contains(Object o)方法
boolean contains(Object o) 判断对象是否存在于集合中,对象存在返回true；方法参数是Object类型.
private static void function_1() {
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("itcast");
coll.add("itheima");
coll.add("money");
coll.add("123");
boolean b = coll.contains("itcast");
System.out.println(b); //true
}1.3.4 remove(Object o)方法
boolean remove(Object o)移除集合中指定的元素。
如果有两个符合条件的元素，remove只删除第一个遇到的元素。
private static void function_3(){
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("money");
coll.add("itcast");
coll.add("itheima");
coll.add("money");
coll.add("123");
System.out.println(coll);//[abc, money, itcast, itheima, money, 123]
boolean b = coll.remove("money");
System.out.println(b); //true
System.out.println(coll);//[abc, itcast, itheima, money, 123]
}
1.3.5 size()方法
学习Java中三种长度表现形式：
- 数组.length 属性 返回值 int
- 字符串.length() 方法,返回值int
- 集合.size()方法, 返回值int
1.3.6 toArray() 方法
Object[] toArray() 是将集合中的元素转成数组中的元素, 即集合转成数组。
返回是一个存储对象的数组, 数组存储的数据类型是Object
private static void function_2() {
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("itcast");
coll.add("itheima");
coll.add("money");
coll.add("123");
Object[] objs = coll.toArray();
for(int i = 0 ; i < objs.length ; i++){
System.out.println(objs[i]);//打印的是数组元素
}
}package day18.demo1;
import java.util.ArrayList;
import java.util.Collection;
/*
* Collection接口中的方法
* 是集合中所有实现类必须拥有的方法
* 使用Collection接口的实现类,程序的演示
* ArrayList implements List
* List extends Collection
* 方法的执行,都是实现的重写
*/
public class CollectionDemo {
public static void main(String[] args) {
function_3();
}
/*
* Collection接口方法
* boolean remove(Object o)移除集合中指定的元素
*/
private static void function_3(){
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("money");
coll.add("itcast");
coll.add("itheima");
coll.add("money");
coll.add("123");
System.out.println(coll);//[abc, money, itcast, itheima, money, 123]
boolean b = coll.remove("money");
System.out.println(b); //true
System.out.println(coll);//[abc, itcast, itheima, money, 123]
}
/* Collection接口方法
* Object[] toArray() 集合中的元素,转成一个数组中的元素, 集合转成数组
* 返回是一个存储对象的数组, 数组存储的数据类型是Object
*/
private static void function_2() {
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("itcast");
coll.add("itheima");
coll.add("money");
coll.add("123");
Object[] objs = coll.toArray();
for(int i = 0 ; i < objs.length ; i++){
System.out.println(objs[i]);
}
}
/*
* 学习Java中三种长度表现形式
* 数组.length 属性 返回值 int
* 字符串.length() 方法,返回值int
* 集合.size()方法, 返回值int
*/
/*
* Collection接口方法
* boolean contains(Object o) 判断对象是否存在于集合中,对象存在返回true
* 方法参数是Object类型
*/
private static void function_1() {
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("itcast");
coll.add("itheima");
coll.add("money");
coll.add("123");
boolean b = coll.contains("itcast");
System.out.println(b);
}
/*
* Collection接口的方法
* void clear() 清空集合中的所有元素
* 集合容器本身依然存在
*/
public static void function(){
//接口多态的方式调用
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("bcd");
System.out.println(coll);
coll.clear();
System.out.println(coll);//[] 只是倒掉水，杯子还在
}
}
第二章 Iterator迭代器
2.1 迭代器的概述
Java中提供了很多个集合，它们在存储元素时，采用的存储方式不同。 取得方式也不一样，未解决此问题，迭代器就出现了，为了统一我们取元素的方式。
Collection集合元素的通用获取方式：在取元素之前先要判断集合中有没有元素， 如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
每种集合的底层的数据结构不同,例如ArrayList是数组,LinkedList底层是链表,但是无论使用那种集合,我们都会有判断是否有元素 以及取出里面的元素的动作,那么Java为我们提供一个迭代器定义了统一的判断元素和取元素的方法。
2.2 迭代器的实现原理
集合中的迭代器: 获取集合中元素方式。
接口 Iterator 的两个抽象方法：
boolean hasNext() 判断集合中还有没有可以被取出的元素,如果有返回true
next() 取出集合中的下一个元素
Collection接口定义方法
Iterator iterator()
ArrayList 重写方法 iterator(),返回了Iterator接口的实现类的对象
使用ArrayList集合的对象
- Iterator it =array.iterator(),运行结果就是Iterator接口的实现类的对象
- it是接口的实现类对象,调用方法 hasNext 和 next 集合元素迭代
- Iterator<String> it = coll.iterator();执行到此步指针才生成，且在-1的位置。遇到next()语句时，指针才后移。迭代器指针只能后移，因此迭代器只能使用一次。
迭代元素图解：
注意:在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。
for循环的迭代器节省内存，因为迭代器是在for循环内建立的，而while的迭代器是在main内建立的。但是一般用while，代码简洁。
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}for (Iterator<String> it2 = coll.iterator(); it2.hasNext(); ) {
System.out.println(it2.next());
}
package day18.demo1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* 集合中的迭代器:
* 获取集合中元素方式
* 接口 Iterator : 两个抽象方法
* boolean hasNext() 判断集合中还有没有可以被取出的元素,如果有返回true
* next() 取出集合中的下一个元素
*
* Iterator接口,找实现类.
* Collection接口定义方法
* Iterator iterator()
* ArrayList 重写方法 iterator(),返回了Iterator接口的实现类的对象
* 使用ArrayList集合的对象
* Iterator it = array.iterator(),运行结果就是Iterator接口的实现类的对象
* it是接口的实现类对象,调用方法 hasNext 和 next 集合元素迭代
*/
public class IteratorDemo {
public static void main(String[] args) {
Collection<String> coll = new ArrayList<String>();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
//迭代器,对集合ArrayList中的元素进行取出
//调用集合的方法iterator()获取出,Iterator接口的实现类的对象
Iterator<String> it = coll.iterator();
//接口实现类对象,调用方法hasNext()判断集合中是否有元素
//boolean b = it.hasNext();
//System.out.println(b);
//接口的实现类对象,调用方法next()取出集合中的元素
//String s = it.next();
//System.out.println(s);
//迭代是反复内容,使用循环实现,循环的条件,集合中没元素, hasNext()返回了false
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
/*for (Iterator<String> it2 = coll.iterator(); it2.hasNext(); ) {
System.out.println(it2.next());
}*/
}
}
2.3 集合迭代中的转型
1. Cllection接口的简单使用，集合中可以存储任何对象，那么存放进去的数据都是还是原来类型吗?
- 不是了，提升成了object.
2. 在使用集合时，我们需要注意以下几点:
- 集合中存储其实都是对象的地址。
- 集合中可以存储基本数值吗? jdk1. 5版本以后可以存储了。因为出现了基本类型包装类，它提供了自动装箱操作(基本类型>对象)， 这样，集合中的元素就是基本数值的包装类对象。
- 存储时提升了Object.取出时要使用元素的特有内容，必须向下转型。
注意：如果集合中存放的是多个对象，这时进行向下转型会发生类型转换异常。
提示：Iterator接口也可以使用<>来控制迭代元素的类型的。
//Iterator接口也可以使用<>来控制迭代元素的类型的。
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("aabbcc");
coll.add("shitcast");
Iterator<String> it = coll.iterator();
while (it.hasNext()) {
String str = it.next();
//当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
System.out.println(str.length());
}
package day18.demo1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo1 {
public static void main(String[] args) {
//集合可以存储任意类型的对象
//集合中,不指定存储的数据类型, 集合什么都存
Collection coll = new ArrayList();
coll.add("abc");//提升为Object类
coll.add("uyjgtfd");
//迭代器获取
Iterator it = coll.iterator();
while(it.hasNext()){
//it.next()获取出来的是什么数据类型,Object类
//Object obj = it.next();
//System.out.println(obj);
String s = (String)it.next();//获取子类特有属性，必须强转
System.out.println(s.length());
}
}
}
第三章 增强for循环遍历数组
3.1 增强for循环
JDK1.5版本后,出现新的接口 java.lang.Iterable，Collection接口开始继承Iterable接口。
Iterable实现增强for循环。
格式:
for( 数据类型 变量名 : 数组或者集合 ){
System.out.println(变量);
}
原理图：增强for循环
将数组中的值赋给i，打印i，未修改数组中的值。
增强for循环：
好处: 代码少了,方便对容器遍历
弊端: 没有索引,不能修改容器里面的元素。
因此增强for循环适合做遍历使用。
package day18.demo1;
import java.util.ArrayList;
/*
* JDK1.5新特性,增强for循环
* JDK1.5版本后,出现新的接口 java.lang.Iterable
* Collection开始继承Iterable
* Iterable作用,实现增强for循环
*
* 格式:
* for( 数据类型 变量名 : 数组或者集合 ){
* sop(变量);
* }
*/
public class ForEachDemo {
public static void main(String[] args) {
function_2();
}
/*
* 增强for循环遍历集合
* 存储自定义Person类型
*/
public static void function_2(){
ArrayList<Person> array = new ArrayList<Person>();
array.add(new Person("a",20));
array.add(new Person("b",10));
for(Person p : array){
System.out.println(p);
}
}
public static void function_1(){
//for对于对象数组遍历的时候,能否调用对象的方法呢
String[] str = {"abc","itcast","cn"};
for(String s : str){
System.out.println(s.length());
}
}
/*
* 实现for循环,遍历数组
* 好处: 代码少了,方便对容器遍历
* 弊端: 没有索引,不能操作容器里面的元素
*/
public static void function(){
int[] arr = {3,1,9,0};
for(int i : arr){
System.out.println(i+1);
}
System.out.println(arr[0]);
}
}
有泛型才可以使用增强for，否则会出现安全隐患。
增强for循环和老式的for循环有什么区别?
注意:增强for 循环必须有被遍历的目标。目标只能是Cllection 或者是数组。
建议:遍历数组时，如果仅为遍历，可以使用增强for。如果要对数组的元素进行操作,使用老式for循环可以通过角标操作。
第四章 泛型类
4.1 泛型的引入
在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成object类型。当我们在取出每一个对象 ，并且进行相应的操作，这时必须采用类型转换。例如：
package day18.demo1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class GenericDemo {
public static void main(String[] args) {
function();
}
public static void function(){
Collection coll = new ArrayList();
coll.add("abc");
coll.add("rtyg");
coll.add("43rt5yhju");
coll.add(1); //有安全隐患，integer类型不能转换为String类型
Iterator it = coll.iterator();
while(it.hasNext()){
String s = (String)it.next();
System.out.println(s.length());
}
}
}
程序在运行时发生了问题java.lang.ClassCastException
为什么会发生类型转换异常呢?、
由于集合中什么类型的元素都可以存储。导致取出时，如果出现强转就会引发运行时ClassCastException异常怎么来解决这个问题呢?
使用集合时，必须明确集合中元素的类型。这种方式称为:泛型。
注意：有泛型才可以使用增强for，否则会出现安全隐患。
package day18.demo1;
//将上述代码加上泛型
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
* JDK1.5 出现新的安全机制,保证程序的安全性
* 泛型: 指明了集合中存储数据的类型 <数据类型>
*/
public class GenericDemo {
public static void main(String[] args) {
function();
}
public static void function(){
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("rtyg");
coll.add("43rt5yhju");
// coll.add(1);
Iterator<String> it = coll.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s.length());
}
}
}
4.2 泛型的定义与使用
泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。JDK1.5 出现新的安全机制,保证程序的安全性。
泛型，指明了集合中存储数据的类型 <数据类型>，即在尖括号中写上数据类型。
定义格式： 修饰符 class 类名<代表泛型的变量> { }
4.3 泛型类、接口
4.3.1 带有泛型的类
ArrayList<E>
E: Element 元素, 实际思想就是一个变量而已
ArrayList<Integer> , E 接受到类型,就是Integer类型
package day18.demo1;
import java.util.ArrayList;
import java.util.Iterator;
/*
* 带有泛型的类
* ArrayList
* E: Element 元素, 实际思想就是一个变量而已
* ArrayList<Integer> , E 接受到类型,就是Integer类型
* public class ArrayList<E>{
*
* public boolean add(Integer e){
* elementData[size++] = e;
* }
*
* public boolean add(E e){}
* }
*
* Iterator<E>
* E next()
*
* Iterator<Integer>
* Integer next()
*
*/
public class GenericDemo1 {
public static void main(String[] args) {
ArrayList<Integer> array = new ArrayList<Integer> ();
array.add(123);
array.add(456);
// ArrayList集合,自己有个方法
// <T> T[] toArray(T[] a)
Integer[] i = new Integer[array.size()];
Integer [] j = array.toArray(i);
for(Integer k : j){
System.out.println(k);
}
}
}
4.3.2 带有泛型的接口
Iterator<E>
Iterator<Integer> ,E 接受到类型,就是Integer类型
泛型的好处
将运行时期的ClassCastException，转移到了编译时期,变成了编译失败。
避免了类型强转的麻烦。
package day18.demo1;
/*
* 带有泛型的接口
*
* public interface List <E>{
* abstract boolean add(E e);
* }
* 实现类,先实现接口,不理会泛型
* public class ArrayList<E> implements List<E>{
* }
* 调用者 : new ArrayList<String>() 后期创建集合对象的时候,指定数据类型
*
* 实现类,实现接口的同时,也指定了数据类型
* public class XXX implements List<String>{
* }
* new XXX()
*/
public class GenericDemo2 {
}
4.4 泛型的通配符
泛型的通配含义：匹配所有的数据类型。
通配符为问号 “？”
//Collection<?> coll
package day18.demo1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
/*
* 泛型的通配符
*/
public class GenericDemo3 {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<String>();
HashSet<Integer> set = new HashSet<Integer>();
array.add("123");
array.add("456");
set.add(789);
set.add(890);
iterator(array);
iterator(set);
}
/*
* 定义方法,可以同时迭代2个集合
* 参数: 怎么实现 , 不能写ArrayList,也不能写HashSet
* 参数: 或者共同实现的接口
* 泛型的通配,匹配所有的数据类型 ?
*/
public static void iterator(Collection<?> coll){
Iterator<?> it = coll.iterator();
while(it.hasNext()){
//it.next()获取的对象,什么类型
System.out.println(it.next());
}
}
}
4.5 泛型的限定
- 格式： ArrayList<? extends Employee> array
- ？代表子类，<? extends Employee>代表继承Employee的任意子类。
- ? extends Employee 限制的是父类, 上限限定, 可以传递Employee,传递他的子类对象
- ? super Employee 限制的是子类, 下限限定, 可以传递Employee,传递他的父类对象
/*
* 定义方法,可以同时遍历3集合,遍历三个集合的同时,可以调用工作方法 work
* ? 通配符,迭代器it.next()方法取出来的是Object类型,怎么调用work方法
* 强制转换: it.next()=Object o ==> Employee 但有安全隐患 String没办法转
* 方法参数: 控制,可以传递Employee对象,也可以传递Employee的子类的对象
* 泛型的限定 本案例,父类固定Employee,但是子类可以无限?
* ? extends Employee 限制的是父类, 上限限定, 可以传递Employee,传递他的子类对象
* ? super Employee 限制的是子类, 下限限定, 可以传递Employee,传递他的父类对象
*/
public static void iterator(ArrayList<? extends Employee> array){
Iterator<? extends Employee> it = array.iterator();
while(it.hasNext()){
//获取出的next() 数据类型,是什么Employee
Employee e = it.next();
e.work();
}
}泛型的限定举例：
package day18.demo2;
/*
* 将的酒店员工,厨师,服务员,经理,分别存储到3个集合中
* 定义方法,可以同时遍历3集合,遍历三个集合的同时,可以调用工作方法
*/
import java.util.ArrayList;
import java.util.Iterator;
public class GenericTest {
public static void main(String[] args) {
//创建3个集合对象
ArrayList<ChuShi> cs = new ArrayList<ChuShi>();
ArrayList<FuWuYuan> fwy = new ArrayList<FuWuYuan>();
ArrayList<JingLi> jl = new ArrayList<JingLi>();
//每个集合存储自己的元素
cs.add(new ChuShi("张三", "后厨001"));
cs.add(new ChuShi("李四", "后厨002"));
fwy.add(new FuWuYuan("翠花", "服务部001"));
fwy.add(new FuWuYuan("酸菜", "服务部002"));
jl.add(new JingLi("小名", "董事会001", 123456789.32));
jl.add(new JingLi("小强", "董事会002", 123456789.33));
// ArrayList<String> arrayString = new ArrayList<String>();
iterator(jl);
iterator(fwy);
iterator(cs);
}
/*
* 定义方法,可以同时遍历3集合,遍历三个集合的同时,可以调用工作方法 work
* ? 通配符,迭代器it.next()方法取出来的是Object类型,怎么调用work方法
* 强制转换: it.next()=Object o ==> Employee 但有安全隐患 String没办法转
* 方法参数: 控制,可以传递Employee对象,也可以传递Employee的子类的对象
* 泛型的限定 本案例,父类固定Employee,但是子类可以无限?
* ? extends Employee 限制的是父类, 上限限定, 可以传递Employee,传递他的子类对象
* ? super Employee 限制的是子类, 下限限定, 可以传递Employee,传递他的父类对象
*/
public static void iterator(ArrayList<? extends Employee> array){
Iterator<? extends Employee> it = array.iterator();
while(it.hasNext()){
//获取出的next() 数据类型,是什么Employee
Employee e = it.next();
e.work();
}
}
}
其他类：
package day18.demo2;
/*
* 定义厨师类
* 属于员工一种,具有额外服务功能
* 继承Employee,实现VIP接口
*/
public class ChuShi extends Employee implements VIP{
//空参数构造方法
public ChuShi(){}
//有参数构造方法
public ChuShi(String name,String id){
super(name,id);
}
//抽象方法重写
public void work(){
System.out.println("厨师在炒菜");
}
public void services(){
System.out.println("厨师做菜加量");
}
}
package day18.demo2;
/*
* 定义经理类
* 属于员工一种,没有VIP功能
* 自己有奖金属性
*/
public class JingLi extends Employee {
//空参数构造方法
public JingLi(){}
//满参数构造方法
public JingLi(String name,String id,double money){
super(name, id);
this.money = money;
}
//定义奖金属性
private double money;
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
//重写抽象方法
public void work(){
System.out.println("管理,谁出错我罚谁");
}
}
package day18.demo2;
/*
* 酒店的VIP服务
* 厨师和服务员
*/
public interface VIP {
public abstract void services();
}
package day18.demo2;
public class Test {
public static void main(String[] args) {
//创建1个经理,2个服务员,2个厨师
JingLi jl = new JingLi("小名", "董事会001", 123456789.32);
jl.work();
FuWuYuan f1 = new FuWuYuan("翠花", "服务部001");
FuWuYuan f2 = new FuWuYuan("酸菜", "服务部002");
f1.work();
f1.services();
f2.work();
f2.services();
ChuShi c1 = new ChuShi("老干妈", "后厨001");
ChuShi c2 = new ChuShi("老干爹", "后厨002");
c1.work();
c1.services();
c2.work();
c2.services();
}
}
package day18.demo2;
/*
* 定义厨师类
* 属于员工一种,具有额外服务功能
* 继承Employee,实现VIP接口
*/
public class FuWuYuan extends Employee implements VIP{
//空参数构造方法
public FuWuYuan() {
super();
}
//满参数构造方法
public FuWuYuan(String name, String id) {
super(name, id);
}
//抽象方法重写
public void work(){
System.out.println("服务员在上菜");
}
public void services(){
System.out.println("服务员给顾客倒酒");
}
}
4553
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
