精华内容
下载资源
问答
  • 如何使用抽象类和抽象方法: 不能直接创建new抽象类对象。 必须用一个子类来继承抽象父类。 子类必须覆盖重写抽象父类当中所有的抽象方法。 覆盖重写(实现):子类去掉抽象方法的abstract关键字,然后补上方法体大...

    2 抽象类

    2.1 抽象的概念

    在这里插入图片描述

    2.2 抽象方法和抽象类的使用

    抽象方法:就是加上abstract关键字,然后去掉大括号,直接分号结束。
    抽象类:抽象方法所在的类,必须是抽象类才行。在class之前写上abstract即可。

    如何使用抽象类和抽象方法:

    1. 不能直接创建new抽象类对象。
    2. 必须用一个子类来继承抽象父类。
    3. 子类必须覆盖重写抽象父类当中所有的抽象方法。
      覆盖重写(实现):子类去掉抽象方法的abstract关键字,然后补上方法体大括号。
    4. 创建子类对象进行使用。
    public abstract class Animal {
    
        // 这是一个抽象方法,代表吃东西,但是具体吃什么(大括号的内容)不确定。
        public abstract void eat();
    
        // 这是普通的成员方法
    //    public void normalMethod() {
    //
    //    }
    
    }
    

    Cat

    public class Cat extends Animal {
    
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    
    }
    

    main

    public class DemoMain {
    
        public static void main(String[] args) {
    //        Animal animal = new Animal(); // 错误写法!不能直接创建抽象类对象
    
            Cat cat = new Cat();
            cat.eat();
        }
    
    }
    

    2.3 抽象类的注意事项

    1. 抽象类不能创建对象,如果创建,编译无法通过而报错。只能创建其非抽象子类的对象。

    理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义。

    1. 抽象类中,可以有构造方法,是供子类创建对象时,初始化父类成员使用的。

    理解:子类的构造方法中,有默认的super(),需要访问父类构造方法。

    1. 抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类。

    理解:未包含抽象方法的抽象类,目的就是不想让调用者创建该类对象,通常用于某些特殊的类结构设计。

    1. 抽象类的子类,必须重写抽象父类中所有的抽象方法,否则,编译无法通过而报错。除非该子类也是抽象类。

    理解:假设不重写所有抽象方法,则类中可能包含抽象方法。那么创建对象后,调用抽象的方法,没有意义。

    Fu

    public abstract class Fu {
    
        public Fu() {
            System.out.println("抽象父类构造方法执行!");
        }
    
        public abstract void eat();
    
    }
    

    Zi

    public class Zi extends Fu { //鼠标放在红线上,alt+回车选择implement method回车,选择eat():void自动生成覆盖重写
    
        public Zi() {
            // super();
            System.out.println("子类构造方法执行");
        }
    
        @Override
        public void eat() {
            System.out.println("吃饭饭");
        }
    }
    

    main

    public class DemoMain {
    
        public static void main(String[] args) {
            Zi zi = new Zi();
            zi.eat();
        }
    
    }
    

    第三点:一个抽象类不一定含有抽象方法,
    只要保证抽象方法所在的类是抽象类,即可。

    这样没有抽象方法的抽象类,也不能直接创建对象,在一些特殊场景下有用途。

    public abstract class MyAbstract {
    }
    

    第四点:抽象类的子类,必须重写抽象父类中所有的抽象方法,否则,编译无法通过而报错。除非该子类也是抽象类。

    // 最高的抽象父类
    public abstract class Animal {
    
        public abstract void eat();
    
        public abstract void sleep();
    
    }
    
    // 子类也是一个抽象类
    public abstract class Dog extends Animal {
    
        @Override
        public void eat() {
            System.out.println("狗吃骨头");
        }
    
        // public abstract void sleep();
    }
    
    public class DogGolden extends Dog {
        @Override
        public void sleep() {
            System.out.println("呼呼呼……");
        }
    }
    
    public class Dog2Ha extends Dog {
        @Override
        public void sleep() {
            System.out.println("嘿嘿嘿……");
        }
    }
    
    public class DemoMain {
    
        public static void main(String[] args) {
    //        Animal animal = new Animal(); // 错误!
    
    //        Dog dog = new Dog(); // 错误,这也是抽象类,不能创建对象
    
            Dog2Ha ha = new Dog2Ha(); // 这是普通类,可以直接new对象。
            ha.eat();
            ha.sleep();
            System.out.println("==========");
    
            DogGolden golden = new DogGolden();
            golden.eat();
            golden.sleep();
        }
    
    
    }
    

    2.4 案例:发红包

    在这里插入图片描述

    //定义父类用户
    public class User {
        private String name; // 姓名
        private int money; // 余额,也就是当前用户拥有的钱数
    
        public User() {
        }
    
        public User(String name, int money) {
            this.name = name;
            this.money = money;
        }
    
        // 展示一下当前用户有多少钱
        public void show() {
            System.out.println("我叫:" + name + ",我有多少钱:" + money);
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getMoney() {
            return money;
        }
    
        public void setMoney(int money) {
            this.money = money;
        }
    }
    
    import java.util.ArrayList;
    // 群主的类
    public class Manager extends User {
    
        public Manager() {
        }
    
        public Manager(String name, int money) {
            super(name, money);
        }
    
        public ArrayList<Integer> send(int totalMoney, int count) {
            // 首先需要一个集合,用来存储若干个红包的金额
            ArrayList<Integer> redList = new ArrayList<>();
    
            // 首先看一下群主自己有多少钱
            int leftMoney = super.getMoney(); // 群主当前余额
            if (totalMoney > leftMoney) {
                System.out.println("余额不足");
                return redList; // 返回空集合
            }
    
            // 扣钱,其实就是重新设置余额
            super.setMoney(leftMoney - totalMoney);
    
            // 发红包需要平均拆分成为count份
            int avg = totalMoney / count;
            int mod = totalMoney % count; // 余数,也就是甩下的零头
    
            // 除不开的零头,包在最后一个红包当中
            // 下面把红包一个一个放到集合当中
            for (int i = 0; i < count - 1; i++) {
                redList.add(avg);
            }
    
            // 最后一个红包
            int last = avg + mod;
            redList.add(last);
    
            return redList;
        }
    }
    
    import java.util.ArrayList;
    import java.util.Random;
    // 普通成员的类
    public class Member extends User {
    
        public Member() {
        }
    
        public Member(String name, int money) {
            super(name, money);
        }
    
        public void receive(ArrayList<Integer> list) {
            // 从多个红包当中随便抽取一个,给我自己。
            // 随机获取一个集合当中的索引编号
            int index = new Random().nextInt(list.size());
            // 根据索引,从集合当中删除,并且得到被删除的红包,给我自己
            int delta = list.remove(index);
            // 当前成员自己本来有多少钱:
            int money = super.getMoney();
            // 加法,并且重新设置回去
            super.setMoney(money + delta);
        }
    }
    
    import java.util.ArrayList;
    public class MainRedPacket {
        public static void main(String[] args) {
            Manager manager = new Manager("群主", 100);
    
            Member one = new Member("成员A", 0);
            Member two = new Member("成员B", 0);
            Member three = new Member("成员C", 0);
    
            manager.show(); // 100
            one.show(); // 0
            two.show(); // 0
            three.show(); // 0
            System.out.println("===============");
    
            // 群主总共发20块钱,分成3个红包
            ArrayList<Integer> redList = manager.send(20, 3);
            // 三个普通成员收红包
            one.receive(redList);
            two.receive(redList);
            three.receive(redList);
    
            manager.show(); // 100-20=80
            // 6、6、8,随机分给三个人
            one.show();
            two.show();
            three.show();
        }
    
    }
    
    展开全文
  • JAVA抽象方法和抽象类的注意事项 1.抽象类不能创建对象 2.抽象类可以有构造方法,供子类使用时,初始化父类成员使用 父类 package demo12; public abstract class Fu { public Fu(){ System.out.println("抽象...

    JAVA中抽象方法和抽象类的注意事项

    1.抽象类不能创建对象
    2.抽象类可以有构造方法,供子类使用时,初始化父类成员使用
    父类

    package demo12;
    
    public abstract class Fu {
        public Fu(){
            System.out.println("抽象父类构造方法");
        }
        public abstract void eat();
    }
    

    子类

    package demo12;
    
    public class Zi extends Fu {
    
        public Zi(){//ALT+ENTER
            super();
            System.out.println("子类构造方法");
    
        }
        @Override
        public void eat() {
            System.out.println("吃饭");
        }
    }
    

    调用

    package demo12;
    
    public class Zi extends Fu {
    
        public Zi(){
            super();
            System.out.println("子类构造方法");
    
        }
        @Override
        public void eat() {
            System.out.println("吃饭");
        }
    }
    

    3.抽象类中不一定有抽象方法,但一定有抽象类

    package demo12;
    
    /*
    * 一个抽象类不一定有抽象方法
    * 只要保证抽象方法所在的类是抽象类即可
    *
    *
    * 这样没有抽象方法的抽象类,也不能直接创造对象,在一些特殊场景有用
    * */
    
    public abstract class MyAbstract {
    }
    

    4.抽象类的子类必须重写所有父类中的抽象方法,否则报错,除非这个子类是抽象的

    Animal(最高的抽象父类)

    package demo13;
    
    public abstract class Animal {
    
        public abstract void eat();
    
        public abstract void sleep();
    }
    

    Dog(子类也是一个抽象类)

    package demo13;
    
    public abstract class Dog extends Animal {
        @Override
        public void eat(){
            System.out.println("狗吃骨头");
        }
    }
    

    Golden

    package demo13;
    
    public class DogGolden extends Dog {//Alt+Enter
        @Override
        public void sleep() {
            System.out.println("呼呼");
        }
    }
    

    2Ha

    package demo13;
    
    public class Dog2Ha extends Dog {//Alt+Enter
        @Override
        public void sleep() {
            System.out.println("嘿嘿。。。");
        }
    }
    

    调用

    package demo13;
    
    public class DemoMain {
        public static void main(String[] args) {
            Dog2Ha ha=new Dog2Ha();
            ha.eat();
            ha.sleep();
            System.out.println("=====");
    
    
            DogGolden g=new DogGolden();
            g.eat();
            g.sleep();
    
        }
    }
    

    结果

    狗吃骨头
    嘿嘿。。。
    =====
    狗吃骨头
    呼呼
    
    展开全文
  • 关于抽象类的使用,以下为语法上要注意的细节,虽然条目较多,但若理解了抽象本质,无需死记硬背。 抽象类不能创建对象,如果创建,编译无法通过而报错。只能创建其非抽象子类对象。 理解:假设创建了抽象类的...

    关于抽象类的使用,以下为语法上要注意的细节,虽然条目较多,但若理解了抽象的本质,无需死记硬背。

    1. 抽象类不能创建对象,如果创建,编译无法通过而报错。只能创建其非抽象子类的对象。
      理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义。
    2. 抽象类中,可以有构造方法,是供子类创建对象时,初始化父类成员使用的。
      理解:子类的构造方法中,有默认的super(),需要访问父类构造方法。
    3. 抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类。
      理解:未包含抽象方法的抽象类,目的就是不想让调用者创建该类对象,通常用于某些特殊的类结构设计。
    4. 抽象类的子类,必须重写抽象父类中所有的抽象方法,否则,编译无法通过而报错。除非该子类也是抽象类。
      理解:假设不重写所有抽象方法,则类中可能包含抽象方法。那么创建对象后,调用抽象的方法,没有意义
    package cn.itcast.day09.demo12;
    public abstract class Fu {
    
        public Fu() {
            System.out.println("抽象父类构造方法执行!");
        }
    
        public abstract void eat();
    
    }
    
    public class Zi extends Fu {
    
        public Zi() {
            // super();
            System.out.println("子类构造方法执行");
        }
    
        @Override
        public void eat() {
    
        }
    
    
    }
    
    /*
    一个抽象类不一定含有抽象方法,
    只要保证抽象方法所在的类是抽象类,即可。
    
    这样没有抽象方法的抽象类,也不能直接创建对象,在一些特殊场景下有用途。
     */
    public abstract class MyAbstract {
    }
    
    public class DemoMain {
    
        public static void main(String[] args) {
            Zi zi = new Zi();
            zi.eat();
        }
    
    }
    
    // 最高的抽象父类
    public abstract class Animal {
    
        public abstract void eat();
    
        public abstract void sleep();
    
    }
    
    
    // 子类也是一个抽象类
    public abstract class Dog extends Animal {
    
        @Override
        public void eat() {
            System.out.println("狗吃骨头");
        }
    
        // public abstract void sleep();
    }
    
    public class DogGolden extends Dog {
        @Override
        public void sleep() {
            System.out.println("呼呼呼……");
        }
    }
    
    public class Dog2Ha extends Dog {
        @Override
        public void sleep() {
            System.out.println("嘿嘿嘿……");
        }
    }
    
    public class DemoMain {
    
        public static void main(String[] args) {
    //        Animal animal = new Animal(); // 错误!
    
    //        Dog dog = new Dog(); // 错误,这也是抽象类
    
            Dog2Ha ha = new Dog2Ha(); // 这是普通类,可以直接new对象。
            ha.eat();
            ha.sleep();
            System.out.println("==========");
    
            DogGolden golden = new DogGolden();
            golden.eat();
            golden.sleep();
        }
    
    
    }
    
    展开全文
  • 3.抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类。 4.抽象类的子类,必须重写抽象父类中所有的抽象方法,否则,编译无法通过而报错。除非该子类也是抽象类。 例如: package 类和对象; import ...

    1.抽象类不能创建对象,如果创建,编译无法通过而报错。只能创建其非抽象子类的对象。

    2.抽象类中,可以有构造方法,是供子类创建对象时,初始化父类成员使用的。

    3.抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类。

    4.抽象类的子类,必须重写抽象父类中所有的抽象方法,否则,编译无法通过而报错。除非该子类也是抽象类。

    例如:

    package 类和对象;
    
    import java.util.Arrays;
    
    public class Democ06 {
        public static void main(String[] args) {
    
    //         Animal animal = new Animal();  // 错误!
    //        Dog dog = new Dog();   // 错误,这也是抽象类。
    
            Dog2Ha ha = new Dog2Ha();  // 相当于使用孙子辈对象
            ha.eat();
            ha.sleep();
            System.out.println("=================");
    
            DogGolden golden = new DogGolden();  // 相当于使用孙子辈对象
            golden.eat();
            golden.sleep();
    
        }
    }
    package 类和对象;
    
    //子类也是一个抽象类
    public abstract class Dog extends Animal {
    
        @Override
        public void eat(){
            System.out.println("狗吃骨头");
        }
    
    }
    package 类和对象;
    
    public class DogGolden extends Dog {
    
    
        @Override
        public void sleep() {
            System.out.println("呼呼呼...");
        }
    }
    package 类和对象;
    
    public class Dog2Ha extends Dog {
        @Override
        public void sleep() {
            System.out.println("嘿嘿嘿...");
        }
    }
    
    展开全文
  • 一、什么是抽象类和抽象方法没有具体功能的实现,通过子类继承后重写方法来实现一定约束的类称之为抽象类,抽象类必须被abstract修饰。抽象方法就是只有方法...三、抽象类和抽象方法的语法规则及其注意事项抽象类...
  • 本篇文章帮大家学习java抽象类和方法,包含了Java抽象类和方法使用方法、操作技巧、实例演示和注意事项,有一定学习价值,大家可以用来参考。Java可以定义这样一个类:这个类不能创建对象。它目的只是表示一个...
  • 一、什么是抽象类和抽象方法没有具体功能的实现,通过子类继承后重写方法来实现一定约束的类称之为抽象类,抽象类必须被abstract修饰。抽象方法就是只有方法...三、抽象类和抽象方法的语法规则及其注意事项抽象类...
  • 抽象类和抽象方法必须使用abstract关键字修饰 public abstract class 类名{} public abstract void eat(); 抽象类中不一定有抽象方法,有抽象方法的一定是抽象类 抽象类不能实例化 抽象类只能参照多态的方式,...
  • day09_17
  • 主要介绍了Java抽象类和抽象方法定义与用法,结合实例形式详细分析了Java抽象类和抽象方法相关原理、定义、使用方法及操作注意事项,需要朋友可以参考下
  • 主要介绍了JAVA抽象类和抽象方法(abstract),结合实例形式分析了java抽象类及抽象方法相关定义、使用技巧与操作注意事项,需要朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 267
精华内容 106
关键字:

java抽象类和抽象方法的注意事项

java 订阅