抽象类
1、抽象方法 abstract
抽象方法:没有代码块并使用abstract修饰的方法,交给非抽象的子类去重写
应用场景:当一个方法必须在父类中出现,但是这个方法又不好实现,就把该方法变成抽象方法,
交给非抽象的子类去实现
需求:编写人类、中国人(四川人、广东人)、日本人
先创一个Person类
package com.dream.test04;
//抽象类
public abstract class Person {
private String name;
private char sex;
private int age;
public Person() {
}
public Person(String name, char sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//抽象方法
public abstract void eat();
public void sleep(){
System.out.println(this.name + "睡觉觉");
}
@Override
public String toString() {
return "Person [name=" + name + ", sex=" + sex + ", age=" + age + "]";
}
}
创一个Japanese类
package com.dream.test04;
public class Japanese extends Person{
private String yearNumber;
public Japanese() {
}
public Japanese(String name, char sex, int age, String yearNumber) {
super(name, sex, age);//子承父类属性
this.yearNumber = yearNumber;
}
public String getYearNumber() {
return yearNumber;
}
public void setYearNumber(String yearNumber) {
this.yearNumber = yearNumber;
}
@Override
public void eat() {
System.out.println(super.getName() + "吃马赛克");
}
@Override
public String toString() {
return "Japanese [yearNumber=" + yearNumber + ", toString()=" + super.toString() + "]";
}
}
创一个Chinese抽象类
package com.dream.test04;
//还是一个抽象类
public abstract class Chinese extends Person{
private String id;
public Chinese() {
}
public Chinese(String name, char sex, int age, String id) {
super(name, sex, age);//子承父类属性
this.id = id;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
//抽象方法
public abstract void hobby();
@Override
public String toString() {
return "Chinese [id=" + id + ", toString()=" + super.toString() + "]";
}
}
在分别创四川、广东类
package com.dream.test04;
public class SiChuan extends Chinese{
public SiChuan() {
}
public SiChuan(String name, char sex, int age, String id) {
super(name, sex, age, id);//子承父类属性
}
@Override
public void hobby() {
System.out.println(super.getName() + "喜欢打麻将");
}
@Override
public void eat() {
System.out.println(super.getName() + "吃火锅");
}
@Override
public String toString() {
return "SiChuan [toString()=" + super.toString() + "]";
}
}
package com.dream.test04;
public class GuangDong extends Chinese{
public GuangDong() {
}
public GuangDong(String name, char sex, int age, String id) {
super(name, sex, age, id);//子承父类属性
}
@Override
public void hobby() {
System.out.println(super.getName() + "喜欢做生意");
}
@Override
public void eat() {
System.out.println(super.getName() + "吃肠粉、潮汕牛肉火锅");
}
@Override
public String toString() {
return "SiChuan [toString()=" + super.toString() + "]";
}
}
测试类:
package com.dream.test04;
public class Test01 {
public static void main(String[] args) {
Japanese j = new Japanese("野田昊", '男', 28, "令和");
j.eat();
System.out.println(j);
SiChuan sc = new SiChuan("lk", '男', 18, "123456789");
sc.eat();
System.out.println(sc);
GuangDong gd = new GuangDong("李嘉诚", '男', 80, "987654321");
gd.eat();
System.out.println(gd);
}
}
2、深入抽象方法:
知识点:深入抽象类及抽象方法
1.抽象类中只能有抽象方法?
抽象类里可以有构造方法、静态方法、成员方法
2.抽象类中不可以没有抽象方法?
可以没有抽象方法,但是这样毫无意义
3.如果父类是抽象类,则子类必须实现父类的抽象方法?
子类如果是抽象类,可以不实现父类对的抽象方法
4.抽象类不能有构造方法?
可以有构造方法的
5.可以使用new关键字来创建抽象类对象?
不可以的,创建出的是匿名内部类的对象
package com.dream.test05;
import com.dream.test04.Chinese;
public class Test01 {
public static void main(String[] args) {
//1.创建匿名类,继承Chinese,重写eat、hobby方法
//2.创建匿名类的对象
//3.赋值给父类的引用 c
Chinese c = new Chinese() {
@Override
public void eat() {
}
@Override
public void hobby() {
}
};
}
}
3、接口
含义:
1.接口是特殊的抽象类
2.接口中只能有静态常量和抽象方法
3.JDK1.8的新特性允许接口中使用默认方法和静态方法 作用:制定规范
创建一个I1接口类
package com.dream.test06;
public interface I1 {
//默认添加public static final
int i = 100;
//默认添加abstract
public void method01();
public void method02();
//默认方法
default void defaultMethod(){
System.out.println("接口中的默认方法");
}
//静态方法
public static void staticMethod(){
System.out.println("接口中的静态方法");
}
}
创建一个A类
package com.dream.test06;
public class A implements I1{
@Override
public void method01() {
}
@Override
public void method02() {
}
}
创建测试类
nepackage com.dream.test06;
public class Test01 {
public static void main(String[] args) {
A a = new A();
a.defaultMethod();
I1.staticMethod();
}
}
4、深入接口
类 - 接口的关系:
类 - 类:单继承
类 - 接口:多实现
接口 - 接口:多继承
1.一个类可以实现多个接口?可以
2.一个接口可以实现多个接口?不可以,接口与接口之间是多继承关系
3.接口里面的方法不一定都是抽象的?JDK1.8开始接口中允许默认方法和静态方法
4.接口解决了类的单继承问题?是的
5.一个类是否可以继承一个类并同时实现多个接口?可以
6.接口可以new对象?不可以,创建的是匿名内部类的对象
创建5个接口:
package com.dream.test07;
public interface I1 {
public void i1Method01();
public void method01();
default void method02(){}
}
package com.dream.test07;
public interface I2 {
public void i2Method01();
public void method01();
default void method02(){}
}
package com.dream.test07;
public interface I3 extends I4,I5{
public void i3Method01();
}
package com.dream.test07;
public interface I4 {
public void i4Method01();
}
package com.dream.test07;
public interface I5 {
public void i5Method01();
}
创建一个A类
package com.dream.test07;
public class A extends Object implements I1,I2,I3{
@Override
public void i2Method01() {
}
@Override
public void i1Method01() {
}
@Override
public void i4Method01() {
}
@Override
public void i5Method01() {
}
@Override
public void i3Method01() {
}
//I1、I2中都有method01的抽象方法,在实现类中只实现一个
@Override
public void method01() {
}
@Override
public void method02() {
//在实现类中调用I1接口中的默认方法
//I1.super.method02();
I2.super.method02();
}
}
创建测试类
package com.dream.test07;
public class Test01 {
public static void main(String[] args) {
//1.创建匿名类,实现I5接口中的i5method01方法
//2.创建匿名类的对象
//3.赋值给接口的引用
I5 i5 = new I5() {
@Override
public void i5Method01() {
}
};
}
}