09--面向对象--访问控制符+抽象类

访问控制符

　　用来控制一个类，或者类中的成员的访问范围。

抽象类

　　概念　　

　　　　　　Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。

　　　　抽象类可以理解为是一个只有方法声明没有方法体的特殊类。

　　特点　

1、  通过java关键字abstract实现
2、  可以修饰方法或者类
3、  抽象类中可以没有抽象方法（由子类去实现）
4、  如果类中有抽象方法，那该类必须定义为一个抽象类
5、  子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写
6、  多用于多态中
7、  抽象类不可以被实例化

　　案例

package cn.tedu.abstractdemo;

        //这个类用来测试 抽象类
        public class Test5_Abstract {
            public static void main(String[] args) {
                // 创建多态对象测试
                Animal an = new Dog();
                an.eat();
                an.play();
            }
        }
        // 2、如果一个类中，包含了抽象方法 ，这个类必须是抽象类
        // 3、抽象类是一个特殊的 类 ，特殊在 抽象类里 可以包含 抽象方法
        abstract class Animal {
            // 1、如果方法没有方法体，就是抽象方法，使用abstract关键字
            abstract public void eat();

            public void play() {
                System.out.println("Animal...play()");
            }
        }
        // 4、子类 如果 继承了 抽象的父类 ，子类两条路：把所有抽象方法都重写 或者 是一个抽象的子类。
        // abstract class Dog extends Animal{
        class Dog extends Animal {
            //5、重写抽象方法
            public void eat() {
                System.out.println("狗吃肉");
            }
        }

 抽象类的使用

　　抽象类中构造方法的使用

　　　　1、抽象类不能被实例化

　　　　2、抽象类本身不能创建对象，但是，为什么会提供构造方法？ ---  是为了子类创建对象时调用  ！！　

package cn.tedu.abstractdemo;

        //这个类用来测试 抽象类的 使用
        public class Test1_UseAbstract {
            public static void main(String[] args) {
                //创建多态对象测试
        //            new Animal() ;  //1、抽象类不能被实例化
                Animal a = new Dog() ; 
            }
        }
        //创建抽象类
        abstract class Animal{
            //3、抽象类本身不能创建对象，但是，为什么会提供构造方法？ ---  是为了子类创建对象时调用  ！！
            public Animal() {    //构造方法
                System.out.println("Animal  ... 无参构造");
            }
        }
        class Dog extends Animal{
            public Dog() {
                //2、子类无参构造中，隐藏着super()
                super() ;
                System.out.println(" Dog  ...无参构造");
            }
        }

　　抽象类中成员变量的使用

　　　　　1、抽象类中可以有成员变量

　　　　　2、抽象类中可以有常量

package cn.tedu.abstractdemo;
        //这个类用来测试 抽象类的 使用成员变量
        public class Test2_UseAbstract {
            public static void main(String[] args) {
                //创建多态对象测试
                Animal2 a = new Dog2();
                System.out.println(  a.name  );
                
                System.out.println( Animal2.COUNTRY );
            }
        }
        //创建抽象类
        abstract class Animal2{
            //1、抽象类中可以有成员变量
            String name = "jack" ;
            //2、抽象类中可以有常量吗？ -- 可以有
            static final String COUNTRY  =  "中国" ;
        }
        class Dog2 extends Animal2{
        }

 

　　抽象类中成员方法的使用

　　　　1、抽象类是一个特殊的类 ，特殊在里面可以有抽象方法和普通方法。(关键看需不需要方法体)

　　　　2、子类如果  继承的父类是一个  抽象类。子类两条路：要么重写所有抽象方法，要么抽象的子类

　　　　3、普通方法重写或者不重写，看你需不需要修改方法体，不需要时也可以不重写。

　　　　4、抽象方法一般都会重写，否则就是一个抽象类了。重写了就用子类的方法体。

        package cn.tedu.abstractdemo;
        //这个类用来测试 抽象类的 使用成员方法
        public class Test3_UseAbstract {
            public static void main(String[] args) {
                //创建多态对象测试
                Animal3 an = new Dog3() ;//父类引用 指向 子类对象
                an.show();//3、普通方法重写或者不重写，看你需不需要修改方法体，不需要时也可以不重写。
                
                an.eat();//编译看左边，运行看右边
                an.play();//4、抽象方法一般都会重写，否则就是一个抽象类了。重写了就用子类的方法体。
            }
        }
        //1、抽象类是一个特殊的类 ，特殊在里面可以有抽象方法和普通方法。(关键看需不需要方法体)
        abstract class Animal3{
            abstract public void eat() ;
            abstract public void play() ;
            public void show() {
                System.out.println("show()...");
            }
        }
        //2、子类如果  继承的父类是一个  抽象类。子类两条路：要么重写所有抽象方法，要么抽象的子类
        //abstract class Dog3 extends Animal3{
        class Dog3 extends Animal3{
            @Override//就是一个重写方法的标记 --- 注解！
             public void eat() {
                 System.out.println("eat()...");
             }
            @Override
             public void play() {
                 System.out.println("play()...");
             }
        }