Java阶段一Day10

文章列表

Java阶段一Day10

文章目录

Java阶段一Day10
- 抽象类和抽象方法
- 接口
- - 案例小练习
- 引用类型数组
教师总结
- 回顾：
- 精华笔记：
- 笔记：
补充：

抽象类和抽象方法

关键字：abstract

只有方法的定义，没有具体的实现（连 { } 都没有）

包含抽象方法的类必须是抽象类，也是由 abstract 修饰

抽象类不能被实例化，即不能被new，是不会单独存在，即一定会有子类

抽象类是需要被继承的，派生类有两种处理方法：1）也声明为抽象类、2）重写抽象方法（常见方法）

只要是个数据类型就能声明变量，就一定能造数组

抽象类的意义：

封装共有的属性和行为，实现代码复用
可以包含抽象方法，为所有派生类统一入口(名字统一)，强制必须重写。

设计规则：适合初学者

找对象抽类，将所有派生类所共有的属性和行为，抽到超类中，抽共性
若派生类的行为/代码都一样，设计为普通方法

若派生类的行为/代码不一样，设计为抽象方法
将部分派生类所共有的行为，抽到接口中

为什么要有抽象方法：做出一个规定，一个强制。为了统一

实际开发中，一个项目一定是团队协作的，以动物案例为例假设在Animal中不设计eat()方法:

张三写Dog类-------------eatSomethink()、李四写Chick类------------eating()、王五写Fish类----------haveSomethink()

赵六想让动物吃，他在调用吃方法的时候就傻眼了，他得知道每个类中的吃的具体的名字,调用起来相当麻烦，因为不统一

在Animal类中设计一个抽象方法eat()表示动物的吃

张三写Dog类-------------eat()、李四写Chick类------------eat()、王五写Fish类--------------eat()

赵六想让动物吃，只需知道Animal中吃的具体名字eat,调用起来就简单了，因为统一

接口

关键字： interface、implements

接口是引用类型，和类是一种平级关系，由interface定义（三种引用类型：数组、类、接口）

接口里面只能包含抽象方法 (常量、默认方法、静态方法、私有方法)

接口也是不完整的，不能被实例化，是需要被实现 (implements)，实现类重写接口中的所有抽象方法，且重写的接口必须是 public的

一个类可以实现多个接口。若又继承又实现时，应先继承后实现。接口可以继承接口

类间关系：同类型是继承关系，不同类型是实现关系

接口小结：

接口是对继承单根性的扩展 ———— 实现多继承（表述对象具备哪些功能，短小精悍）
接口常常充当标准、规范，若实现了某接口，说明具备某功能，若不实现某接口则不具备某功能（如Serializable）

案例小练习

需求:

教研总监;名字、年龄、工资、上班打卡()、下班打卡()、完成工作()、

解决企业问题、培训员工()、编辑书籍()

讲师:名字、年龄、工资、上班打卡()、下班打卡()、完成工作()、

解决企业问题()、培训员工()、编辑书籍()

项目经理:名字、年龄、工资、上班打卡()、下班打卡()、完成工作()、

编辑书籍()

班主任:名字、年龄、工资、上班打卡()、下班打卡()、完成工作(）

/*
超类  雇员类	名字、年龄、工资  上班打卡、下班打卡、完成工作（抽象方法）派生类   教研总监类 继承超类、重写抽象方法，第一、二个接口讲师类 继承超类、重写抽象方法，第一、二个接口项目经理类 继承超类、重写抽象方法，第二个接口班主任 继承超类、重写抽象方法接口   解决企业问题、培训员工接口编辑书籍接口
*/

抽象类和接口的区别是什么：

共同点 ：

都不能被实例化。
都可以包含抽象方法。
都可以有默认实现的方法（Java 8 可以用 default 关键字在接口中定义默认方法）。

区别：

接口主要用于对类的行为进行约束，实现了某接口就具有对应的行为。抽象类主要用于代码复用，强调的是所属关系。
一个类只能继承一个类，但是可以实现多个接口。
接口中的成员变量只能是 public static final 类型的，不能被修改且必须有初始值，而抽象类的成员变量默认 default，可在子类中被重新定义，也可被重新赋值。

引用类型数组

数组元素为引用类型的数组，即为引用类型数组

基本类型数组和引用类型数组的区别：

给引用类型数组的元素赋值时，需要new个对象
访问引用类型数组元素的属性/行为时，需要通过元素去打.访问

null：表示空，没有指向任何对象
若引用的值为null，则该引用不能再进行任何点操作了，若操作则发生NullPointerException空指针异常

教师总结

回顾：

继承：
- 代码复用、extends、超类:共有的派生类:特有的
- 派生类可以访问派生类的和超类的，但超类不能访问派生类的
- 单一继承，具有传递性
- java规定：构造派生类之前必须先构造超类
  - 若派生类的构造方法中没有调用超类构造方法，则默认super()调超类无参构造方法
  - 若派生类的构造方法中调用了超类构造方法，则不再默认提供
    
    super()调用超类构造方法，必须位于派生类构造方法的第1行
super：指代当前对象的超类对象
- super.成员变量名-----------------------访问超类的成员变量
- super.方法名()----------------------------调用超类的方法
- super()--------------------------------------调用超类的构造方法
方法的重写(override/overriding)：
- 发生在父子类中，方法名相同，参数列表相同
- 重写方法被调用时，看对象的类型

精华笔记：

抽象方法：
- 由abstract修饰
- 只有方法的定义，没有具体的实现(连{}都没有)
抽象类：
- 由abstract修饰
- 包含抽象方法的类必须是抽象类，但不包含抽象方法的类也可以声明为抽象类
- 抽象类不能被实例化(new对象)
- 抽象类是需要被继承的，派生类：
  - 必须重写所有抽象方法------------------变不完整为完整
  - 也声明为抽象类----------------------------一般不这么用
- 抽象类的意义：
  - 封装共有的属性和行为------------------代码复用
  - 可以包含抽象方法，为所有派生类统一入口(名字统一)，强制必须重写
接口：
- 是一种引用数据类型
- 由interface定义
- 只能包含抽象方法(常量、默认方法、静态方法、私有方法------暂时搁置)
- 不能被实例化
- 接口是需要被实现/继承的，实现类/派生类：必须重写接口中的所有抽象方法
  - 注意：重写接口中的方法时，必须加public(先记住)
- 一个类可以实现多个接口，用逗号分隔。若又继承又实现时，应先继承后实现
- 接口可以继承接口
引用类型数组：------记住它和基本类型数组的两种区别即可
- 区别1：给引用类型数组的元素赋值时，需要new个对象
- 区别2：访问引用类型数组的元素的属性/行为时，需要打点访问
综合练习：达内员工管理系统

笔记：

抽象方法：
- 由abstract修饰
- 只有方法的定义，没有具体的实现(连{}都没有)

抽象类：

由abstract修饰
包含抽象方法的类必须是抽象类，但不包含抽象方法的类也可以声明为抽象类
抽象类不能被实例化(new对象)
抽象类是需要被继承的，派生类：
- 必须重写所有抽象方法------------------变不完整为完整
- 也声明为抽象类----------------------------一般不这么用

抽象类的意义：

封装共有的属性和行为------------------代码复用

可以包含抽象方法，为所有派生类统一入口(名字统一)，强制必须重写

public abstract class Animal {String name;int age;String color;Animal(String name,int age,String color){this.name = name;this.age = age;this.color = color;}void drink(){System.out.println(color+"色的"+age+"岁的"+name+"正在喝水...");}abstract void eat();
}public class Dog extends Animal{Dog(String name,int age,String color){super(name,age,color);}void lookHome(){System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在看家...");}void eat(){System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在吃肯头...");}
}public class Chick extends Animal {Chick(String name,int age,String color){super(name,age,color);}void layEggs(){System.out.println(color+"色的"+age+"岁的小鸡"+name+"正在下蛋...");}void eat(){System.out.println(color+"色的"+age+"岁的小鸡"+name+"正在吃小米...");}
}public class Fish extends Animal {Fish(String name,int age,String color){super(name,age,color);}void eat(){System.out.println(color+"色的"+age+"岁的小鱼"+name+"正在吃小虾...");}
}

接口：

是一种引用数据类型
由interface定义

只能包含抽象方法(常量、默认方法、静态方法、私有方法------暂时搁置)

interface Inter {abstract void show();void test(); //接口中的方法默认都是抽象的，前面默认有abstract//void say(){} //编译错误，抽象方法不能有方法体
}

不能被实例化

public class InterfaceDemo {public static void main(String[] args) {//Inter o = new Inter(); //编译错误，接口不能被实例化}
}

接口是需要被实现/继承的，实现类/派生类：必须重写接口中的所有抽象方法

注意：重写接口中的方法时，必须加public(先记住)

interface Inter {abstract void show();void test(); //接口中的方法默认都是抽象的，前面默认有abstract//void say(){} //编译错误，抽象方法不能有方法体
}
class InterImpl implements Inter {public void show(){ //重写接口中的抽象方法时，必须加public}public void test(){}
}

一个类可以实现多个接口，用逗号分隔。若又继承又实现时，应先继承后实现

//演示接口的多实现
interface Inter1{void show();
}
interface Inter2{void test();
}
abstract class Aoo{abstract void say();
}
class Boo extends Aoo implements Inter1,Inter2{public void show(){}public void test(){}void say(){}
}

接口可以继承接口

//演示接口继承接口
interface Inter3{void show();
}
interface Inter4 extends Inter3{void test();
}
class Coo implements Inter4{public void test(){}public void show(){}
}

public abstract class Animal {String name;int age;String color;Animal(String name,int age,String color){this.name = name;this.age = age;this.color = color;}void drink(){System.out.println(color+"色的"+age+"岁的"+name+"正在喝水...");}abstract void eat();
}public interface Swim {/** 游泳 */void swim();
}public class Dog extends Animal implements Swim {Dog(String name,int age,String color){super(name,age,color);}void lookHome(){System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在看家...");}void eat(){System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在吃肯头...");}public void swim(){System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在游泳...");}
}public class Fish extends Animal implements Swim {Fish(String name,int age,String color){super(name,age,color);}void eat(){System.out.println(color+"色的"+age+"岁的小鱼"+name+"正在吃小虾...");}public void swim(){System.out.println(color+"色的"+age+"岁的小鱼"+name+"正在游泳...");}
}public class Chick extends Animal {Chick(String name,int age,String color){super(name,age,color);}void layEggs(){System.out.println(color+"色的"+age+"岁的小鸡"+name+"正在下蛋...");}void eat(){System.out.println(color+"色的"+age+"岁的小鸡"+name+"正在吃小米...");}
}
public class SwimTest {public static void main(String[] args) {Dog dog = new Dog("小黑", 2, "黑");dog.eat();      //Dog类重写之后的dog.drink();    //复用Animal类的dog.swim();     //Dog类重写之后的dog.lookHome(); //Dog类所特有的Chick chick = new Chick("小白", 1, "白");chick.eat();     //Chick类重写之后的chick.drink();   //复用Animal类的chick.layEggs(); //Chick类所特有的Fish fish = new Fish("小金", 1, "金");fish.eat();   //Fish类重写之后的fish.drink(); //复用Animal类的fish.swim();  //Fish类重写之后的}
}

引用类型数组：------记住它和基本类型数组的两种区别即可

区别1：给引用类型数组的元素赋值时，需要new个对象

区别2：访问引用类型数组的元素的属性/行为时，需要打点访问

public class RefArrayDemo {public static void main(String[] args) {Dog[] dogs = new Dog[3];dogs[0] = new Dog("小黑",2,"黑");dogs[1] = new Dog("小白",1,"白");dogs[2] = new Dog("小灰",3,"灰");System.out.println(dogs[0].name); //输出第1只狗狗的名字dogs[1].age = 4; //修改第2只狗狗的年龄为4岁dogs[2].swim(); //第3只狗狗在游泳for(int i=0;i<dogs.length;i++){ //遍历dogs数组System.out.println(dogs[i].name); //输出每只狗狗的名字dogs[i].eat(); //每只狗狗吃饭}Chick[] chicks = new Chick[2];chicks[0] = new Chick("小花",1,"花");chicks[1] = new Chick("大花",2,"白");for(int i=0;i<chicks.length;i++){ //遍历chicks数组System.out.println(chicks[i].name);chicks[i].layEggs();}Fish[] fish = new Fish[4];fish[0] = new Fish("小金",2,"金");fish[1] = new Fish("大金",4,"白");fish[2] = new Fish("小绿",1,"绿");fish[3] = new Fish("小红",3,"红");for(int i=0;i<fish.length;i++){ //遍历fish数组System.out.println(fish[i].color);fish[i].drink();}/*//声明Dog型数组dogs，包含3个元素，每个元素都是Dog类型，默认值为nullDog[] dogs = new Dog[3];//声明Chick型数组chicks，包含3个元素，每个元素都是Chick类型，默认值为nullChick[] chicks = new Chick[3];//声明Fish型数组fish，包含2个元素，每个元素都是Fish类型，默认值为nullFish[] fish = new Fish[2];*/}
}

综合练习：达内员工管理系统

需求:
1)教研总监:名字、年龄、工资、上班打卡()、下班打卡()、完成工作()、解决企业问题()、培训员工()、编辑书籍()
2)讲师:名字、年龄、工资、上班打卡()、下班打卡()、完成工作()、解决企业问题()、培训员工()、编辑书籍()
3)项目经理:名字、年龄、工资、上班打卡()、下班打卡()、完成工作()、编辑书籍()
4)班主任:名字、年龄、工资、上班打卡()、下班打卡()、完成工作()设计:
1)雇员超类:名字、年龄、工资、上班打卡(){}、下班打卡(){}、abstract 完成工作()
2)企业顾问接口: 解决企业问题()、培训员工()
3)技术作者接口: 编辑书籍()
4)教研总监类，继承雇员超类，实现企业顾问接口和技术作者接口: 重写4个抽象方法
5)讲师类，继承雇员超类，实现企业顾问接口和技术作者接口: 重写4个抽象方法
6)项目经理类，继承雇员超类，实现技术作者接口: 重写2个抽象方法
7)班主任类，继承雇员超类: 重写1个抽象方法

补充：

设计规则：-----------适合初学者
- 将所有派生类共有的属性和行为，抽到超类中-------------抽共性
- 若派生类的行为/代码都一样，设计普通方法
  
  若派生类的行为/代码不一样，设计抽象方法
- 将部分派生类共有的行为，抽到接口中
  - 接口对继承单根性的扩展------------------------实现多继承
  - 接口是一种标准、规范，若实现了某接口就具备某个的功能，若不实现接口就不具备那个功能----------后期才能理解得更好
类间关系：
- 类和类-------------------------------继承
- 接口和接口-------------------------继承
- 类和接口----------------------------实现
null：表示空，没有指向任何对象。
- 若引用的值为null，则该引用不能再进行任何操作了，若操作则发生NullPointerException空指针异常。

明日单词：

1)polymorphic:多态
2)cast:转换
3)Master:主人
4)feed:喂
5)instanceof:实例
6)Inner:内部
7)Outer:外部
8)anonymous:匿名

Java阶段一Day10

Java阶段一Day10

文章目录

抽象类和抽象方法

接口

案例小练习

引用类型数组

教师总结

回顾：

精华笔记：

笔记：

补充：

相关问题

公告