Java之继承与代码块分类

代码块分类

代码块分类:
    1.局部代码块: 限制变量作用域(生命周期)
      书写位置: 在方法中
    2.构造代码块(在开发中 很少使用)
      书写位置: 在类中 方法外
      调用时机: 如果你有构造代码块 系统会帮你调用
                帮你在创建对象之前调用 每次创建对象都会调用
    3.静态代码块(一定是被static修饰)
      静态代码块 依赖类 随着类加载而加载
      注意:只加载一次(系统调用 只调用一次 不管你创建多少对象)
      应用场景:加载驱动(数据库驱动 JDBC)
    4.同步代码块(多线程)

实例:
    public class Demo01 {
        public static void main(String[] args) {
            /*
            {
                System.out.println("我是局部代码块");
            }
            */

            // 创建两个person对象  调用sayhi方法
            Person person = new Person();
            person.setName("sxm");
            person.setAge(20);
            person.sayHi();

            Person person2 = new Person("yy", 20);
            person2.sayHi();
        }
    }

    class Person{
        private String name;
        private int  age;

        static {
            System.out.println("我是静态代码块");
        }

        {
            // 比如 我每个对象都会调用同一个方法  这时可以使用
            sleep();
            System.out.println("我是构造代码块");
        }

        // 无参构造方法
        public Person() {
            System.out.println("我是无参的构造方法");
        }
        // 有参构造方法
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
            System.out.println("我是有参的构造方法");
        }

        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public void sayHi() {
            System.out.println(name + "  " + age);
        }

        public void sleep() {
            System.out.println("睡觉");
        }   
    }

继承

继承的特点:
    1.减少你的代码量
    2.让类与类之间 产生关联(产生 父子关系)

继承使用的关键字 extends

注意:
    1.继承时可把多个类中 相同的功能或方法 抽取出来,重新构造一个类出来 把这些类 建立继承关系
    2.建立继承关系的同时  一定要符合逻辑(切记不要为了继承而继承)

继承的写法:
    class 子类 extends 父类{

    }

继承实例:
        public class Demo02 {
            public static void main(String[] args) {
                // 创建一个猫  
                // 子类继承了父类 方法 和属性
                Cat cat = new Cat();
                cat.name = "汤姆";
                cat.kind = "灰猫";
                cat.catchMice();
                cat.sleep();
            }
        }

        // 抽取出相同的部分 组成 动物类
        class Animal{
            String name;
            String color;
            String kind;
            // 睡觉
            public void sleep() {
                System.out.println("睡觉");
            }
        }


        class Cat extends Animal{
            // 抓老鼠
            public void catchMice() {
                System.out.println("抓老鼠");
            }
        }

        class Dog extends Animal{
            // 啃骨头
            public void eatBone() {
                System.out.println("啃骨头");
            }
        }

java中的继承
注意:
    1.Java 只允许 单继承(多继承可以使用接口来间接实现)
    2.Java中 允许 多层继承(例如:爷爷 父亲 儿子 孙子...)

Java中 最顶层的父类(最基础的类) Object类
如果一个类 没有写继承哪个父类 默认就是继承Object类

1.如何 使用这些类中 共有方法/属性
    创建 当前继承中 最顶端类 去使用
2.如何 使用这些类中 特有方法/属性
    创建 当前继承中 最末端类 去使用

多层继承实例:
        //A类爷爷类 B类父类  C类孙子类
        //A类中  有name  C类中 会叫爷爷
        class A{
            String name;
        }
        class B extends A{

        }
        class C extends B{
            public void speak() {
                System.out.println("会叫爷爷");
            }
        }

构造方法不能被继承

为了保证继承的完整性,在你创建子类对象的时候,如果你不调用 父类的构造方法,那么系统会默认帮你调用 父类的无参构造方法
代码示例:

        public class Demo04 {
            public static void main(String[] args) {
                Son son = new Son();
                son.name = "儿子";
                son.sayHi();
                System.out.println("------------");
                Son son2 = new Son("小明");
                son2.sayHi();
            }
        }

        class Father{
            String name;
            public Father() {
                System.out.println("我是爸爸类无参构造方法");
            }
            public Father(String name) {
                this.name = name;
                System.out.println("我是爸爸类有参构造方法");
            }
            public void sayHi() {
                System.out.println(name);
            }
        }

        class Son extends Father{
            public Son() {
                // 实际上  如果你没有在子类的构造方法中 调用 父类的构造方法 
                // 系统会默认给你的 子类构造方法中 添加一行代码
                super(); // 调用父类的 构造方法  并且是无参的构造方法
                // super这个关键字  相当于  父类的对象
                System.out.println("我是儿子类无参的构造方法");
            }
            public Son(String name) {
                super(); // 系统帮你默认调用父类的构造方法
                this.name = name;
                System.out.println("我是儿子类有参的构造方法");
            }
        }

如果父类没有无参构造方法 如何解决?
解决方法如下:
        class Phone{
            String name;
        //  public Phone() {
        //      
        //  }
            public Phone(String name) {
                this.name = name;
            }
        }

        class Mi extends Phone{
            public Mi() {
                // 子类的构造方法中  如果你什么都不写  会默认调父类无参构造方法
                // 如果 父类 没有无参的构造方法  就证明 父类当中 一定有 有参的构造方法
                // 无论 有参 还是 无参  在子类的构造方法中   必须调用一个 
                // 必须手动指定一个有参构造方法去调用
                super("note");
            }
            public Mi(String name) {
                super(name);
                this.name = name;
            }
        }
建议: 不管父类 还是子类 构造方法 一定写全 避免出现问题

super和this 关键字

super代表的是父类的对象

super 调用对象   super点对象
      调用方法   super点方法

this代表的是本类的对象

super(); 调用的是父类的构造方法
this();  调用的是本类的构造方法

例如:
    public class Demo05 {
        public static void main(String[] args) {
            TestB b = new TestB();
            b.fun();
        }
    }


    class TestA{
        int num1 = 10;
        int num2 = 20;
    }

    class TestB extends TestA{
        int num1 = 30;
        public void fun() {
            // 使用 this 时  会先在本类中寻找该属性 
            //  没找到  就去父类中找
            System.out.println(this.num1);//30
            System.out.println(this.num2);//20
            System.out.println(super.num1);//10
        }
    }

方法的重写

方法的重写
注意:
    1.方法声明完全一致的时候 叫方法重写
    2.方法的重写 建立在 类与类 之间有继承关系 (子类重写父类的方法)

Override(重写) 和 Overload(重载) 的区别
            1.重写:    前提 需要继承关系
              重载:    在同一个类里
            2.重写:    需要方法的声明  完全一致
              重载:    只跟参数有关

方法的重写代码示例:
        public class Demo07 {
            public static void main(String[] args) {
                IOS8 ios8 = new IOS8();
                ios8.siri();
                // 如果直接打印  对象  相当于 系统会帮你 在打印时  调用toString()方法
                System.out.println(ios8);
            }
        }

        class IOS7 {
            public void call() {
                System.out.println("打电话");
            }
            public void siri() {
                System.out.println("说英文");
            }
        }


        class IOS8 extends IOS7{

            @Override // 注解  标识这个方法是重写父类的方法
            public void siri() {
                // 调不调  父类的方法  要根据实际情况
                super.siri();
            }

            /*
            // 方法的重写: 对父类的方法  进行一个功能上的升级
            public void siri() {
                // 中英都会
                super.siri();  // 调用父类的方法
                System.out.println("说中文");
            }
            */

            // 重写toString()方法
            // 可以利用  toString() 方法  来写  介绍自己的方法
            @Override
            public String toString() {
                // TODO Auto-generated method stub
                return "哈哈哈哈";
            }
        }

重写方法练习

需求:
    老师类 学生类  
    无参 有参构造 set/get方法 成员变量私有化 介绍自己的方法
    属性:姓名,年龄
    行为:吃饭
    老师有特有的方法:讲课
    学生有特有的方法:学习

    public class Demo08 {
        public static void main(String[] args) {
            // 创建一个学生
            Student student = new Student("yyy",18,5);
            System.out.println(student);
        }
    }

    // 人类
    class People{
        // 继承中 private修饰的变量 是不能直接访问的
        private String name;
        private int age;
        // 无参
        public People() {

        }
        // 有参
        public People(String name, int age) {
            this.name = name;
            this.age = age;
        }

        // get/set 方法
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }

        // 介绍自己的方法
        @Override
        public String toString() {
            return "姓名:" + name + "  年龄:" + age;
        }
    }

    // 老师类
    class Teacher extends People{
        // 无参构造方法
        public Teacher() {
            super();
        }
        // 有参构造方法
        public Teacher(String name, int age) {
            super(name, age);
        }
        // 讲课方法
        public void teach() {
            System.out.println("讲课");
        }
    }

    // 学生类
    class Student extends People {
        private int num;
        // 无参构造方法
        public Student() {
            super();
        }
        // 有参构造方法
        public Student(String name, int age, int num) {
            // 直接调用父类的构造方法  完成初始化
            // 为了保证继承的完整性 在子类构造方法中
            // 第一行 必须调用父类的构造方法 (无参有参都行)
            super(name, age);
            // 特有属性直接赋值
            this.num = num;
        }

        @Override
        public String toString() {
            // 可以在父类的基础上 添加自己特有的属性去打印
            return super.toString() + " 学号:" + num;
        }

        // 学习方法
        public void learn() {
            System.out.println("学习");
        }
    }