定义一个抽象类，类名AaaClass。并在其中定义两个方法，抽象方法aaaMeth()和普通方法meth()。
通过该类的子类来实现该类。谢谢了

1. package com.lee.calc.copy003;
   
2. 
   
3. public class Test {
   
4.     public static void main(String []args){
   
5.         AaaClass b = new BbbClass();
   
6.         b.aaaMeth();
   
7.         b.meth();
   
8.         
   
9.         AaaClass c = new CccClass();
   
10.         c.aaaMeth();
    
11.         c.meth();
    
12.     }
    
13. }
    
14. 
    
15. abstract class AaaClass{
    
16.     abstract void aaaMeth();
    
17.     void meth(){
    
18.         System.out.println("抽象类中的meth方法");
    
19.     }
    
20. }
    
21. 
    
22. class BbbClass extends AaaClass{
    
23. 
    
24.     @Override
    
25.     void aaaMeth() {
    
26.         System.out.println("BbbClass子类实现了抽象父类的aaaMeth方法");
    
27.         
    
28.     }
    
29.    
    
30. }
    
31. 
    
32. class CccClass extends AaaClass{
    
33. 
    
34.     @Override
    
35.     void aaaMeth() {
    
36.         System.out.println("CccClass子类实现了抽象父类的aaaMeth方法");
    
37.         
    
38.     }
    
39.    
    
40. }

复制代码

输出结果：

BbbClass子类实现了抽象父类的aaaMeth方法
抽象类中的meth方法
CccClass子类实现了抽象父类的aaaMeth方法
抽象类中的meth方法

我代码以附件形式回复，你看看，应该对你有帮助。

/*定义一个抽象类，类名AaaClass。并在其中定义两个方法，抽象方法aaaMeth()和普通方法meth()。
通过该类的子类来实现该类。*/
public class test {
public static void main(String[] args) {
  AaaClass aaa = new subClass();   //这里初始化子类
  aaa.aaaMeth();     //调用aaaMeth方法
  aaa.meth();       //调用Meth方法
}
}
abstract class AaaClass
{
public abstract void aaaMeth();
public void meth()
{
  System.out.println("这是抽象类的普通方法meth");
}
}
class subClass extends AaaClass
{
  @Override
public void aaaMeth()    //在子类中必须要重写这个方法
  {
   System.out.println("在子类中实现了AaaClass的抽象方法aaaMeth");
}
}

/*
* 定义一个抽象类，类名AaaClass。并在其中定义两个方法，抽象方法aaaMeth()和普通
* 方法meth()。通过该类的子类来实现该类。
* */
abstract class AaaClass{
        int x = 3;
        abstract void aaaMeth();
        public void meth(){
                System.out.println("我是抽象类");
        }
}
class SonAssClass extends AaaClass{
        int x = 4;
        void aaaMeth() {
                int x =5;
                //其实，在这些继承关系中，将每个类中的属性搞清楚之后，应该就没有什么问题
                System.out.println("我重写了父类的aaaMeth方法");
                System.out.println("获取父类对象的x"+super.x);
                System.out.println("获取子类对象的x"+this.x);
                System.out.println("获取本方法的x"+x);
        }
       
}
public class RunAaaClass {
        public static void main(String args[]){
                SonAssClass son = new SonAssClass();
                son.aaaMeth();
                son.meth();
        }
}

还是多看看视频教程吧，里面有详细解答
给个例子你看看

public class Test03 {
        public static void main(String Args[]){
                BbbClass b = new BbbClass();
                int z =100;
                 int sum1 = b.aaaMeth(z);
                System.out.print(sum1);
        }
       
}

abstract class AaaClass{
       
        public void meth(int x, int y){
                int tem = x;
                x = y ;
                y = tem;
        }
       
        public abstract int aaaMeth(int x);
}

class BbbClass extends AaaClass{
       

        public int aaaMeth(int i) {
                // TODO Auto-generated method stub
                if(i==1){
                        return 1;
                }
                else
                        return i+ aaaMeth(i-1);
        }
}