JAVA萌新学习day12
一.回顾
1.Object类,是所有类的父亲，默认继承Object
equals()方法：判断两个对象是否相等
return this == obj;
**==:**基本类型比较的数据，引用类型比较的地址。
equals() 默认和 == 一样。
String 中 equals 重写了 Object 中的 equals 方法。
hashCode()方法：返回对象的地址。
getClass()方法：返回类对象，获取类的名称。
toString()方法：返回对象的字符串形式。
2.**多态：**同一个父类引用类型，使用了不同的子类实例，执行不同的操作，父类引用，子类对象。
实现多态的要素或条件：
2.1 子类继承父类，子类必须重写父类的方法
2.2 使用父类变量，子类对象
多态表现形式：
2.3 使用父类作为方法的参数
2.4 使用父类作为方法的返回值
向上转型和向下转型：
向上转型：子类转成父类。
向下转型：父类转成子类，前提必须先向上转型，才能向下转型。
**instanceof:**判断对象是否是某种类型。
例如：
if(pet instanceof Dog){
Dog dog = (Dog)pet;
}
3.final 终止的
3.1 final 修饰的变量，表示常量，只能赋值一次。
当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。本质上是一回事，因为引用的值是一个地址，final要求值，即地址的值不发生变化。
final修饰成员变量：
final修饰一个成员变量（属性），必须要显示初始化。这里有两种初始化方式，一种是在变量声明的时候初始化；第二种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。
当函数的参数类型声明为final时，说明该参数是只读型的。即你可以读取使用该参数，但是无法改变该参数的值。
例如：
class Man{
private final int i = 0;
public Man(){
i = 1;
final Object obj = new Object();
obj = new Object();
}
}
//上面的一段代码中，对变量i和obj的重新复制都报错了。
3.2 final修饰方法：终止方法不能被重写，可以被继承。
3.3 final修饰类：终止类，不能被继承。
复习完了，今天就开始学习新的内容啦！那么看看今天的任务吧！
1.抽象类
2.抽象方法
3.接口
二.抽象
1.为什么要使用抽象类
有些类创建对象不具体，需要把这个定义为抽象类
1. Animal animal = newAnimal();
2. Pet pet = new Pet;
使用 abstract 修饰类变成抽象类：不能实例化，只能被继承。
抽象类的构造方法不能直接使用，只能被子类调用。
2.abstract 关键字
abstract
可以修饰类：叫做抽象类。
可以修饰方法：叫做抽象方法，没有方法体，需要使用分号表示生命结束，抽象方法所在的类必须是抽象类。
子类必须重写父类的抽象方法，除非子类也是抽象类。
3.抽象方法
使用abstract关键字修饰，只表示声明了一个方法，但是没有任何实现。
特点：
- 没有方法体，需要使用分号表示方法声明结束。
- 如果一个类中有一个方法是抽象的，那么这个类必须是抽象的。
- 抽象方法必须被子类重写，除非子类也是抽象类。
4.抽象类
使用abstract关键字修饰
特点：
- 抽象类中可以包含抽象方法，也可以不包含抽象方法。
2)抽象类中有构造方法，但是不能创建对象，构造方法可以在子类中会被调用。
3)抽象类的存在就是为了被继承，子类必须重写父类的抽象方法，除非子类也是抽象类。
5.抽象类和普通类的区别
1)抽象类需要abstract，而普通类不需要。
2)构造方法：都有，但是抽象类不能实例化对象，普通类可以。
3)成员方法：抽象类中可以纯在抽象方法也可以存在非抽象方法，而普通类中只能存在非抽象方法。
- 两个关键字修饰方法
final修饰的方法特点：可以被继承不能被重写；
abstract修饰的方法特点：必须被重写；
所以这两个关键字不能同时修饰同一个方法。 - 两个关键字修饰类时：
final修饰的类特点：不能被继承；
abstract修饰的方法特点：必须被重写；
所以这两个关键字不能修饰同一个类。 - final的类种不能有abstract方法，abstract方法必须是abstract类，abstract类是必须被重写的,而final修饰的类不能被继承。
- abstract类中可以有final方法，final方法可以被继承。
三.接口
1.接口的概念
从语法上讲：借口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有方法的实现。
从功能上讲：接口表示一种约定(规范)或能力。
2.接口的好处
·扩展类的功能，保持对外借口一致。
·接口实现了多重继承，完成类和任何实现接口子类的同心和交互。
·降低了代码之间的耦合性。
3.接口的特点
1)接口不能创建对象，而且接口没有构造方法。
2)接口中的方法一般都是共有抽象方法：public abstract。
3)接口中所有的属性都是共有静态属性：public static final。
在一个接口中声明方法是，若没有声明访问权限，默认也是public，若没其他修饰默认也是abstract；
声明属性时，若没有声明访问权限和静态常量，默认也是 public static final。
4.接口的声明语法
关键字 interface ：表示一个接口，接口 interface 和类 class 是平级关系。
接口命名习惯：
如果接口表示一种能力，命名采用：名字+后缀able,比如 Serializable Comprarble。
如果接口表示一种约定或规范，按照类的命名规范 Usb，Comparator，CharSequence
语法：
public interface 接口名{
//接口中的成员：抽象方法和静态常量.
}
5.接口的实现类
接口与类的关系：implements：实现
一个类可以实现多个接口。
语法：
public interface I{
public abstract void fun();
}
public class Impl implements I{
public void fun(){
}
}
/*
一个类实现某个接口之后，可以存在父类，实现接口和继承类不冲突。
*/
//若一个类有父类同时也实现接口，声明类时，必须先继承在实现接口
语法：
public calss Dog extends Animal implements I{
public void fun(){
}
}
6.接口的分类
1)普通接口：在接口中可以声明抽象方法和静态常量属性。
2)常量群接口：在接口中只声明一组静态常量属性。
3)标志性接口：在接口中没有抽象方法，作用为了标记某个类具有某个功能。
7.接口和接口的关系
继承关系：使用关键字extends实现接口与接口的继承关系。
接口继承的特点：
1)接口中没有私有成员，所以父接口中的所有成员都会被子接口继承。
2)父子关系中都是接口，所以子接口中不需要实现任何抽象方法。
3)接口可以多继承。
例如：
现有类A和类B，两个类中都有fun()方法，假如类C继承类A和类B，当使用类C的对象调用fun方法时，如何执行？此时不知道执行哪个fun()方法,所以类不可多继承
现有接口A,B，两个接口中都有fun方法，接口C继承A,B，由于接口中的没有方法体，所以只要在接口C中存在了fun方法即可，所以接口支持多继承。
8.接口中的特殊方法
- JDK1.8之后接口中使用static关键字修饰的方法有方法体
静态方法需要有方法体，注意只能通过 接口名.方法 调用，因为不能被继承。 - JDK1.8之后接口中使用default关键字修饰的方法有方法体
可以被继承，通过现实类调用。
9.抽象类和接口的区别
语法：
1)抽象类使用abstract,接口使用interface
2)抽象类中可以包含抽象方法，也可以包含非抽象方法，接口中只能包含抽象方法和静态常量，jdk1.8之后接口可以包含静态方法和默认方法。
3)抽象类和接口都不能实例化
4)抽象类可以包含构造方法，接口中没有构造方法。
功能：
1)抽象类一般用来表示同类实物，接口可以表示不同类实物。
2)抽象类可以实现代码的重用，也可以约束子类的功能，接口就是约束显示类的功能，降低代码之间的耦合性。
使用场景：
1)程序或模块内部使用抽象类
2)程序架构或模块之间使用接口
四.程序
ComplexDemo
/*
* 1.Person(人，父类)
* 2.Student Teacher(学生 老师)抽象类
* 3.SmallStudent MiddleStudent 继承于 Student
* 4.SmallTeacher MiddleTeacher 继承于 Teacher
* 5.SmallInterface MiddleInterface 两个接口
*/
public class ComplexDemo {
public static void main(String[] args) {
System.out.println("ComplexDemo.main");
ComplexManager.test();
}
}
Person
//人 类 我们本程序中的根类
public abstract class Person {
//姓名
String name;
//年龄
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;
}
//抽象方法，所有子类必须重写
public abstract void eat();
public void sleep(){
System.out.println("Person.sleep");
}
}
Student
public abstract class Student extends Person{
//学号
int number;
//所在学校名称
String schoolName;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getSchoolName() {
return schoolName;
}
public void setSchoolName(String schoolName) {
this.schoolName = schoolName;
}
//学习的方法
public abstract void study();
}
Teacher
public abstract class Teacher extends Person {
//老师所教学科
String subject;
//工资
int money;
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
//给学生上课
public abstract void teachStudent();
}
SmallStudent
public class SmallStudent extends Student{
//爱好
String love;
//用来记录产生的小学生数量
public static int count = 0;
public SmallStudent(){
this("玩游戏");
}
public SmallStudent(String love){
//记录有一个新的学生产生了学号
count ++;
this.love = love;
}
//玩游戏的方法
public void playGame(){
System.out.println("SmallStudent.playGame" + this );
}
public String getLove() {
return love;
}
public void setLove(String love) {
this.love = love;
}
@Override
//重写父类继承来的方法，为了能让系统帮我们直接打印对象内容
public String toString(){
String str = "姓名：" + name + "；年龄：" + age + "；爱好：" + love + "；学号：" + number + "；学校" + schoolName;
System.out.println();
return str;
}
@Override
public void study() {
System.out.println("SmallStudent.study" + this);
}
@Override
public void eat() {
System.out.println("SmallStudent.eat" + this);
}
}
MiddleStudent
public class MiddleStudent extends Student {
//朋友
String friend;
//用来记录产生的中学生数量
public static int count = 0;
public MiddleStudent(){
this("没朋友");
}
public MiddleStudent(String friend) {
count ++;
this.friend = friend;
}
public String getFriend() {
return friend;
}
public void setFriend(String friend) {
this.friend = friend;
}
@Override
public String toString(){
String str = "姓名：" + name + " 年龄：" + age + " 朋友：" + friend + " 学校：" + schoolName;
return str;
}
@Override
public void study() {
System.out.println("MiddleStudent.study");
}
@Override
public void eat() {
System.out.println("MiddleStudent.eat");
}
}
SmallTeacher
public class SmallTeacher extends Teacher implements SmallInterface,MiddleInterface{
//技能
String skill;
public SmallTeacher(){
this("能歌善舞");
}
public SmallTeacher(String skill) {
this.skill = skill;
}
public void findParent(){
System.out.println("SmallTeacher.findParent" + "有问题找家长");
}
public String getSkill() {
return skill;
}
public void setSkill(String skill) {
this.skill = skill;
}
@Override
public String toString(){
String str = "姓名：" + name + "；年龄：" + age + "；技能" + skill + "；学科：" + subject + "；工资：" + money;
return str;
}
@Override
public void teachStudent() {
System.out.println("SmallTeacher.teachStudent" + this);
}
@Override
public void eat() {
System.out.println("SmallTeacher.eat" + this);
}
@Override
public void dance(){
System.out.println("SmallTeacher.dance" + this);
}
@Override
public void english() {
System.out.println("SmallTeacher.english" + this);
}
}
MiddleTeacher
public class MiddleTeacher extends Teacher implements SmallInterface,MiddleInterface{
String otherJob;
public MiddleTeacher(){
this("带孩子");
}
public MiddleTeacher(String otherJob) {
this.otherJob = otherJob;
}
@Override
public String toString(){
String str = "姓名：" + name +"职业：" + otherJob + "，学科：" + subject + ",工资：" + money;
return str;
}
@Override
public void teachStudent() {
System.out.println("MiddleTeacher.teachStudent" + this);
}
@Override
public void eat() {
System.out.println("MiddleTeacher.eat" + this);
}
@Override
public void english() {
System.out.println("MiddleTeacher.english" + this);
}
@Override
public void dance() {
System.out.println("MiddleTeacher.dance" + this);
}
}
接口MiddleInterface
public interface MiddleInterface {
//会英语
public void english();
}
接口SmallInterface
public interface SmallInterface {
//会跳舞
public void dance();
}
ComplexManager
import java.util.Random;
public class ComplexManager {
public static void test() {
//创建一个Person数组，用来保存所有对象
Person[] persons = new Person[10];
for (int i = 0; i < persons.length; i++) {
Person p =null;
if(i % 2 == 0) {
//p = createPerson(1);
p = createPerson(3);
}
else{
//p = createPerson(2);
p = createPerson(4);
}
if(p != null){
persons[i] = p;
}
}
//测试每一个对象的使用
for (int i = 0; i < persons.length; i++) {
//打印当前对象的额值
System.out.println(persons[i]);
//测试当前的方法调用
print(persons[i]);
}
}
public static void print(Person p){
//检查当前对象类型
if(p instanceof SmallStudent){
SmallStudent s = (SmallStudent)p;
s.playGame();
System.out.println();
}
else if(p instanceof MiddleStudent){
MiddleStudent m = (MiddleStudent)p;
m.study();
System.out.println();
}
//检查当前对象是否实现了指定接口
if(p instanceof MiddleInterface){
((MiddleInterface)p).english();
}
if(p instanceof SmallInterface){
((SmallInterface)p).dance();
}
}
public static void printTeacher(Person q){
//检查当前对象类型
if(q instanceof SmallTeacher){
SmallTeacher st = (SmallTeacher)q;
st.english();
System.out.println();
}
else if(q instanceof MiddleTeacher){
MiddleTeacher mt = (MiddleTeacher)q;
mt.dance();
}
}
//获得指定长度的随机字符串
private static String randomString(int length){
String source = "abcdefghijklmnopqrstuvwxyz";
Random random = new Random();
String result = "";
for (int i = 0; i < length; i++) {
int index = random.nextInt(source.length());
//从原字符串中获取指定索引位置字符
result += source.charAt(index);
}
return result;
}
//创建一个随机学科
private static String randomStringTeacher(){
Random a = new Random();
String[] randombOject = new String[3];
randombOject[0] = "Math";
randombOject[1] = "China";
randombOject[2] = "English";
String b = " ";
for (int i = 0; i < randombOject.length; i++) {
b = randombOject[a.nextInt(2)];
}
return b;
}
public static Person createPerson(int type){
Person p = null;
Random r = new Random();
Random me = new Random();
switch(type){
case 1:
//创建一个小学生对象
SmallStudent s = new SmallStudent();
String name = randomString(5);
s.setName(name);
int age = r.nextInt(6) + 6;
s.setAge(age);
String love = randomString(10);
s.setLove(love);
int number =1000 + SmallStudent.count;
s.setNumber(number);
String schoolName = randomString(15);
s.setSchoolName(schoolName);
p = s;
System.out.println();
break;
case 2:
//创建一个中学生对象
MiddleStudent m = new MiddleStudent();
name = randomString(5);
m.setName(name);
age = r.nextInt(6) + 12;
m.setAge(age);
String friend = randomString(5);
m.setFriend(friend);
number = 2000 + MiddleStudent.count;
m.setNumber(number);
schoolName = randomString(15);
m.setSchoolName(schoolName);
p = m;
System.out.println();
break;
case 3:
//创建一个小学老师对象
SmallTeacher st = new SmallTeacher();
name = randomString(4);
st.setName(name);
age = r.nextInt(10) + 20;
st.setAge(age);
String subject = randomStringTeacher();
st.setSubject(subject);
int money = me.nextInt(3000) + 3000;
st.setMoney(money);
p = st;
System.out.println();
break;
case 4:
//创建一个中学老师对象
MiddleTeacher mt = new MiddleTeacher();
name = randomString(4);
mt.setName(name);
age = r.nextInt(30) + 30;
mt.setAge(age);
subject = randomStringTeacher();
mt.setSubject(subject);
money = me.nextInt(3000) + 7000;
mt.setMoney(money);
p = mt;
System.out.println();
break;
}
return p;
}
}
Keyboard
import com.qf.java1904.day12.Usb;
import com.qf.java1904.day12.Vga;
public class Keyboard implements Usb, Vga {
@Override
public void connect() {
System.out.println("Keyboard.connect");
}
@Override
public void vgaConnect() {
}
}
扫一扫
753
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
