http://bbs.itheima.com/thread-3077-1-1.html

（一）抽象类

1、抽象类的概念：

        1.如果父类会规定出一些成员方法，需要子类去重写，那么在父类中就可以只定义这个方法，不实现它。这种方法叫：抽象方法。使用一个关键字：abstract

        2.抽象方法没有方法体：

          abstract void show();//没有大括号，只有方法声明

        3.当一个类中包含了一个抽象方法时，那么这个类必须是一个抽象类，仍然使用关键字：abstract修饰；

        4.当一个类是抽象类时，说明：

          1).此类不能被实例化；就是用来被继承；

          2).如果一个类继承了一个抽象类，那么子类必须实现父类中所有的抽象方法；否则子类也必须是个抽象类；也就是：一个抽象类可以继承自另一个抽象类；

          3).继承自抽象类仍然使用关键字：extends

          4).Java中是单继承，一个类只能同时继承自一个类；抽象类也是一样，一个类也是只能同时继承自一个抽象类；

       

        抽象类反而形成了一种规定：

        1.要求所有的人员类，都具有void show()方法，怎么规定呢？

          1).定义一个抽象类，里面定义一个抽象方法：abstract void show();

          2).要求所有的具体的人员，都继承自那个抽象类，那么在语法上，就必须重写父类的方法；所以这样达到一个所有人员类都具有了void show()方法。

        项目经理先定义一个抽象类：

        abstract class AbstractService{

                abstract void save();//增

                abstract void delete();//删

                abstract void update();//改

                abstract void find();//查

        }

        要求各小组，所有对数据库操作的类，都必须继承自这个类；

/3、抽象类的特点：

        1.一个抽象类中可以不包含抽象方法；

          可以包含：成员变量、抽象方法、实现的方法；

        2.抽象类不能被实例化：

        3.抽象类的子类可以是个抽象类，也可以是个普通类，如果是普通类必须全部实现抽象类中抽象方法；

abstract class Person{

        String name;

        int age;

        Person(){

                System.out.println("抽象类Person的构造函数");

        }

        Person(String name,int age){

                this.name = name;

                this.age = age;

        }

        /*

        void show(){

                System.out.println("大家好，我是好程序班的一员");

        }

        */

        //把show()做为一个抽象方法

        abstract void show();

}

class Student extends Person

{

        Student(String name,int age){

                super(name,age);//将name和age传给抽象的父类；

        }

        //重写父类show

        void show(){

                System.out.println("大家好，我是好程序班的一名学生");

        }

}

class Teacher extends Person

{

        void show(){

                System.out.println("大家好，我是好程序班的一名教师");

        }

}

class Demo

{

        public static void main(String[] args)

        {

                Student stu = new Student();

                stu.show();//大家好，我是好程序班的一员

                Teacher tea = new Teacher();

                tea.show();//大家好，我是好程序班的一员

        }

}

3、abstract不能和哪些关键字共存：

        1.private:

                一个abstract方法就是用来被子类重写的，所以子类必须能访问父类的抽象方法，所以父类的抽象方法不能是private;

        2.final:

                一个abstract方法是用来被子类重写的，被声明为final的方法是最终方法，不允许重写。所以冲突；一个abstract类是用来被继承的，被声明为final的类是最终类，不能被继承。所以冲突；

        3.static:

                一个abstract方法没有方法体。而一个static的方法在第一次使用类的时候就会被分配空间，而此时，抽象类的方法没有方法体，所以也就无法为其分配空间。所以不能是abstract又是static的.

4、使用抽象类作为方法形参：

        1.一个方法的形参可以接收一个抽象类类型的；

        2.此方法接收一定要是抽象类的子类对象的引用；因为抽象类本身不能被实例化；

        3.到方法体内，实际上就是一种多态的表现形式。父类的引用指向子类的对象；

        了解一下事情：

        1.抽象类类型可以作为方法形参；

        2.当传递实参时，传递的一定要是抽象类的子类的对象的引用；

        3.在方法内部，实际上就是父类的引用指向了子类的对象。实际就是多态的形式

abstract class AbstractA

{

        void show();

}

class SubA extends AbstractA

{

        void show(){

                System.out.println("show()");

        }

}

class SubB extends AbstractA

{

        void show(){

                System.out.println("SubB-->show()");

        }

}

class C

{

}

class B

{

        void print(AbstractA aObj){//0x7788    多态的形式。父类的引用指向之类对象

                aObj.show();

        //  0x7788.show();

        }

}

class Demo

{

        public static void main(String[] args)

        {

                B b = new B();

                SubA aObj = new SubA();//0x7788

                b.print(aObj);//0x7788

                SubB aObj2 = new SubB();

                b.print(aObj2);

                C c = new C();

        //        b.print(c);//编译错误。C不是AbstractA的子类；

        }

}

http://bbs.itheima.com/thread-3077-1-1.html

（一）抽象类

1、抽象类的概念：

        1.如果父类会规定出一些成员方法，需要子类去重写，那么在父类中就可以只定义这个方法，不实现它。这种方法叫：抽象方法。使用一个关键字：abstract

        2.抽象方法没有方法体：

          abstract void show();//没有大括号，只有方法声明

        3.当一个类中包含了一个抽象方法时，那么这个类必须是一个抽象类，仍然使用关键字：abstract修饰；

        4.当一个类是抽象类时，说明：

          1).此类不能被实例化；就是用来被继承；

          2).如果一个类继承了一个抽象类，那么子类必须实现父类中所有的抽象方法；否则子类也必须是个抽象类；也就是：一个抽象类可以继承自另一个抽象类；

          3).继承自抽象类仍然使用关键字：extends

          4).Java中是单继承，一个类只能同时继承自一个类；抽象类也是一样，一个类也是只能同时继承自一个抽象类；

       

        抽象类反而形成了一种规定：

        1.要求所有的人员类，都具有void show()方法，怎么规定呢？

          1).定义一个抽象类，里面定义一个抽象方法：abstract void show();

          2).要求所有的具体的人员，都继承自那个抽象类，那么在语法上，就必须重写父类的方法；所以这样达到一个所有人员类都具有了void show()方法。

        项目经理先定义一个抽象类：

        abstract class AbstractService{

                abstract void save();//增

                abstract void delete();//删

                abstract void update();//改

                abstract void find();//查

        }

        要求各小组，所有对数据库操作的类，都必须继承自这个类；

/3、抽象类的特点：

        1.一个抽象类中可以不包含抽象方法；

          可以包含：成员变量、抽象方法、实现的方法；

        2.抽象类不能被实例化：

        3.抽象类的子类可以是个抽象类，也可以是个普通类，如果是普通类必须全部实现抽象类中抽象方法；

abstract class Person{

        String name;

        int age;

        Person(){

                System.out.println("抽象类Person的构造函数");

        }

        Person(String name,int age){

                this.name = name;

                this.age = age;

        }

        /*

        void show(){

                System.out.println("大家好，我是好程序班的一员");

        }

        */

        //把show()做为一个抽象方法

        abstract void show();

}

class Student extends Person

{

        Student(String name,int age){

                super(name,age);//将name和age传给抽象的父类；

        }

        //重写父类show

        void show(){

                System.out.println("大家好，我是好程序班的一名学生");

        }

}

class Teacher extends Person

{

        void show(){

                System.out.println("大家好，我是好程序班的一名教师");

        }

}

class Demo

{

        public static void main(String[] args)

        {

                Student stu = new Student();

                stu.show();//大家好，我是好程序班的一员

                Teacher tea = new Teacher();

                tea.show();//大家好，我是好程序班的一员

        }

}

3、abstract不能和哪些关键字共存：

        1.private:

                一个abstract方法就是用来被子类重写的，所以子类必须能访问父类的抽象方法，所以父类的抽象方法不能是private;

        2.final:

                一个abstract方法是用来被子类重写的，被声明为final的方法是最终方法，不允许重写。所以冲突；一个abstract类是用来被继承的，被声明为final的类是最终类，不能被继承。所以冲突；

        3.static:

                一个abstract方法没有方法体。而一个static的方法在第一次使用类的时候就会被分配空间，而此时，抽象类的方法没有方法体，所以也就无法为其分配空间。所以不能是abstract又是static的.

4、使用抽象类作为方法形参：

        1.一个方法的形参可以接收一个抽象类类型的；

        2.此方法接收一定要是抽象类的子类对象的引用；因为抽象类本身不能被实例化；

        3.到方法体内，实际上就是一种多态的表现形式。父类的引用指向子类的对象；

        了解一下事情：

        1.抽象类类型可以作为方法形参；

        2.当传递实参时，传递的一定要是抽象类的子类的对象的引用；

        3.在方法内部，实际上就是父类的引用指向了子类的对象。实际就是多态的形式

abstract class AbstractA

{

        void show();

}

class SubA extends AbstractA

{

        void show(){

                System.out.println("show()");

        }

}

class SubB extends AbstractA

{

        void show(){

                System.out.println("SubB-->show()");

        }

}

class C

{

}

class B

{

        void print(AbstractA aObj){//0x7788    多态的形式。父类的引用指向之类对象

                aObj.show();

        //  0x7788.show();

        }

}

class Demo

{

        public static void main(String[] args)

        {

                B b = new B();

                SubA aObj = new SubA();//0x7788

                b.print(aObj);//0x7788

                SubB aObj2 = new SubB();

                b.print(aObj2);

                C c = new C();

        //        b.print(c);//编译错误。C不是AbstractA的子类；

        }

}