文章目录
一、抽象类
1.抽象类用abstract修饰
astract class A{//抽象类,用astract修饰
}
2.抽象类不能被实例化
abstract class A{
abstract public void A();//抽象方法
}
public class Main{
public static void main(String[] args) {
A a=new A();//报错了
}
}
3.作为抽象类的非抽象子类可以创建对象
abstract class A{
abstract public void A();//抽象方法
}
class B extends A{
@Override
public void A() {//覆写抽象方法
System.out.println("hello world!");//有具体的实现
}
}
public class Main{
public static void main(String[] args) {
B b=new B();//可以创建对象
}
}
所以一般用抽象父类声明的方法,是通过子类来具体实现的
4.抽象类与普通类的区别就是可以包含抽象方法
抽象类中不一定要有抽象方法
abstract class A{//抽象类
abstract public void A();//抽象方法,可以没有
public int a=10;//可以有普通成员
public String name="ff";//普通成员
public static void B(){//可以有普通方法
System.out.println("hallo world!");
};
5.抽象类的子类要重写抽象类中的抽象方法
父类中有抽象方法存在,则需要覆写抽象方法(通过子类将父类中抽象方法的具体实现),如果子类是抽象类则可以不覆写
abstract class A{
abstract public void A();//抽象方法
}
class B extends A{
@Override
public void A() {//覆写抽象方法,没有报错
System.out.println("hello world!");//有具体的实现
}
}
abstract class A{
abstract public void A();//抽象方法
}
class B extends A{//没有覆写抽象方法,报错
}
abstract class B extends A{}//将子类变成抽象类后没有报错,但是不能实例化
二、向上转型
直接赋值
abstract class Animal {
public int age;
public String name;
public Animal(int age, String name) {
this.age = age;
this.name = name;
}
abstract void Break();//抽象类
}
class Cat extends Animal{
public Cat(int age, String name) {
super(age, name);
}
public void Break(){//重写抽象类
System.out.println(name+"在猫叫");
}
}
class Duck extends Animal {
public Duck(int age,String name){
super(age,name);
}
public void Break(){//重写抽象类
System.out.println(name+"在鸭叫");
}
}
public class Main{
public static void main(String[] args) {
Cat cat=new Cat(12,"xx");//实例化子类对象
Duck duck=new Duck(12,"xx");//实例化子类对象
Animal animal=cat;//子类对象直接赋值
Animal animal2=duck;//子类对象直接赋值
animal.Break();//向上转型,被赋予的子类对象不同,具体实现的方法也不同
animal2.Break();//向上转型,被赋予的子类对象不同,具体实现的方法也不同
}
}
xx在猫叫
xx在鸭叫
作为方法的参数
abstract class Animal {
public int age;
public String name;
public Animal(int age, String name) {
this.age = age;
this.name = name;
}
abstract void Break();//抽象类
}
class Cat extends Animal{
public Cat(int age, String name) {
super(age, name);
}
public void Break(){//重写抽象类
System.out.println(name+"在猫叫");
}
}
class Duck extends Animal {
public Duck(int age,String name){
super(age,name);
}
public void Break(){
System.out.println(name+"在鸭叫");
}
}
public class Main{
public static void func(Animal animal){
animal.Break();//向上转型,参数对应的子类对象不同,具体实现的方法也不同
}
public static void main(String[] args) {
func(new Cat(1,"xx"));//子类对象作为方法参数
func(new Duck(1,"xx"));//子类对象作为方法参数
}
}
输出结果:
xx在猫叫
xx在鸭叫
作为方法的返回值
abstract class Animal {
public int age;
public String name;
public Animal(int age, String name) {
this.age = age;
this.name = name;
}
abstract void Break();//抽象类
}
class Cat extends Animal{//继承Animal
public Cat(int age, String name) {
super(age, name);
}
public void Break(){//重写
System.out.println(name+"在猫叫");
}
}
class Duck extends Animal {
public Duck(int age,String name){
super(age,name);
}
public void Break(){//重写
System.out.println(name+"在鸭叫");
}
}
public class Main{
public static Animal func(){
System.out.println("1>>Cat"+" "+"2>>Duck");//1是猫,2是鸭子
Scanner scanner=new Scanner(System.in);
int scan= scanner.nextInt();//选择猫或鸭子
if(scan==1){
return new Cat(12,"xx");//子类对象作为返回值
}else {
return new Duck(12,"xx");//子类对象作为返回值
}
}
public static void main(String[] args) {
while(true) {
Animal animal = func();
animal.Break();//向上转型,返回的子类对象不同,具体实现的方法也不同
}
输出结果:
1>>Cat 2>>Duck
2
xx在鸭叫
1>>Cat 2>>Duck
1
xx在猫叫