zoukankan      html  css  js  c++  java
  • 08_面向对象【帮助文档的制作和作用、如何使用JDK提供的帮助文档、代码块概述(局部代码块,构造代码块,静态代码块)和讲解、继承】

    1:如何制作帮助文档(了解)
        (1)写一个类
        (2)加入文档注释
        (3)通过javadoc工具生成即可
            javadoc -d 目录 -author -version ArrayTool.java

    在控制台下的命令:

    E:...>javadoc -d doc -author -version ArrayTool.java

     版本1

    ArrayDemo.java

    /*
        
        静态除了用于共享,还可以用来制作工具类。【静态方法】
        我想要对数组进行操作
        
        在同一个文件夹下,类定义在两个文件中和定义在一个文件中其实一样的。
    */
    class ArrayDemo {
        public static void main(String[] args) {
            //定义数组
            int[] arr = {28,55,37,46,19};
            
            //需求:遍历数组
            /*
            for(int x=0; x<arr.length; x++) {
                if(x == arr.length-1) {
                    System.out.println(arr[x]);
                }else {
                    System.out.print(arr[x]+", ");
                }
            }
            */
            
            //如果我有多个数组都要进行遍历,那么,代码的重复度就很高
            //如何改进呢?用方法改进
            //调用
            //静态方法
            //printArray(arr);
            
            //非静态方法
            //ArrayDemo ad = new ArrayDemo();
            //ad.printArray(arr);
            
            //测试类的作用:创建其他类的对象,调用其他类的功能。
            //而我们现在的操作是跟数组相关的,所以,你应该把这些操作定义到数组操作类中
            //定义一个数组的操作类
            //有了数组操作类之后的调用
            //ArrayTool at = new ArrayTool();
            //at.printArray(arr);
            
            //方法改进为静态后,就可以直接通过类名调用
            ArrayTool.printArray(arr);
        }
        
        /*
        public static void printArray(int[] arr) {
            for(int x=0; x<arr.length; x++) {
                if(x == arr.length-1) {
                    System.out.println(arr[x]);
                }else {
                    System.out.print(arr[x]+", ");
                }
            }
        }
        */
        
        //假设该方法不是静态的
        /*
        public void printArray(int[] arr) {
            for(int x=0; x<arr.length; x++) {
                if(x == arr.length-1) {
                    System.out.println(arr[x]);
                }else {
                    System.out.print(arr[x]+", ");
                }
            }
        }
        */
    }
    
    

    ArrayTool.java

    class ArrayTool {
        
        //把构造方法私有,外界就不能再创建对象了
        private ArrayTool(){}
    
        public static void printArray(int[] arr) {
            for(int x=0; x<arr.length; x++) {
                if(x == arr.length-1) {
                    System.out.println(arr[x]);
                }else {
                    System.out.print(arr[x]+", ");
                }
            }
        }
    }
    

    版本2:【制作帮助文档】

    ArrayDemo.java

    /*
        
        我想要对数组进行操作
        
        如何制作一个说明书呢?
            A:写一个工具类
            B:对这个类加入文档注释
                怎么加呢?
                加些什么东西呢?
            C:用工具解析文档注释
                javadoc工具
            D:格式
                javadoc -d 目录 -author -version ArrayTool.java
                
                目录:就可以写一个文件夹的路径
                
        制作帮助文档出错:
            找不到可以文档化的公共或受保护的类:告诉我们类的权限不够
    */
    class ArrayDemo {
        public static void main(String[] args) {
            //定义数组
            int[] arr = {28,55,37,46,19};
            
            //遍历
            ArrayTool.printArray(arr);
    
            //获取最值
            int max = ArrayTool.getMax(arr);
            System.out.println("max:"+max);
            
            //获取55的索引值
            int index = ArrayTool.getIndex(arr,55);
            System.out.println("index:"+index);
        }
    }
    
    

    ArrayTool.java

    /**
    * 这是针对数组进行操作的工具类
    * @author 刘意
    * @version V.10
    */
    public class ArrayTool {
        
        //把构造方法私有,外界就不能在创建对象了
        /**
        * 这是私有构造
        */
        private ArrayTool(){}
    
        /**
        * 这是遍历数组的方法,遍历后的格式是:[元素1, 元素2, 元素3, ...]
        * @param arr 这是要被遍历的数组
        */
        public static void printArray(int[] arr) {
            System.out.print("[");
            for(int x=0; x<arr.length; x++) {
                if(x == arr.length-1) {
                    System.out.println(arr[x]+"]");
                }else {
                    System.out.print(arr[x]+", ");
                }
            }
        }
        
        /**
        * 这是获取数组中最大值的方法
        * @param  arr 这是要获取最大值的数组
        * @return 返回数组中的最大值
        */
        public static int getMax(int[] arr) {
            int max = arr[0];
            
            for(int x=1; x<arr.length; x++) {
                if(arr[x] > max) {
                    max = arr[x];
                }
            }
            
            return max;
        }
        
        /**
        * 获取指定元素在数组中第一次出现的索引,如果元素不存在,就返回-1
        * @param arr 被查找的数组 
        * @param value 要查找的元素
        * @return 返回元素在数组中的索引,如果不存在,返回-1
        */
        public static int getIndex(int[] arr,int value) {
            int index = -1;
            
            for(int x=0; x<arr.length; x++) {
                if(arr[x] == value) {
                    index = x;
                    break;
                }
            }
            
            return index;
        }
    }
    

    2:通过JDK提供的API学习了Math类(掌握)
        (1)API(Application Programming Interface)
            应用程序编程接口(帮助文档)
        (2)如何使用呢?
            请参照
                day08code2_如何使用JDK提供的帮助文档如何使用帮助文档.txt
        (3)Math类
            A:是针对数学进行操作的类
            B:没有构造方法,因为它的成员都是静态的
            C:产生随机数
                public static double random(): [0.0,1.0)
            D:如何产生一个1-100之间的随机数
                int number = (int)(Math.random()*100)+1;
            E:猜数字小游戏

    如何使用帮助文档.txt

    /*
    1:打开帮助文档
    2:点击显示,找到索引,看到输入框
    3:知道你要找谁?以Scanner举例
    4:在输入框里面输入Scanner,然后回车
    5:看包
        java.lang包下的类不需要导入,其他的全部需要导入。
        
        要导入:
        java.util.Scanner
    6:再简单的看看类的解释和说明,别忘了看看该类的版本
    7:看类的结构
        成员变量    字段摘要     
        构造方法    构造方法摘要 
        成员方法     方法摘要
    8:学习构造方法    
        A:有构造方法    就创建对象
        B:没有构造方法    成员可能都是静态的
    9:看成员方法
        A:左边
            是否静态:如果静态,可以通过类名调用
            返回值类型:人家返回什么,你就用什么接收。
        B:右边
            看方法名:方法名称不要写错
            参数列表:人家要什么,你就给什么;人家要几个,你就给几个
            */
    
    如何使用帮助文档.txt

    MathDemo.java

    /*
        Math:类包含用于执行基本数学运算的方法
        
        由于Math类在java.lang包下,所以不需要导包。
        特点:
            没有构造方法,因为它的成员全部是静态的。
         在源码中,Math类的构造方法为私有的
          private Math() {}
            
        掌握一个方法:
            获取随机数
            public static double random():返回带正号的 double 值,该值大于等于 0.0 且小于 1.0。
    */
    class MathDemo {
        public static void main(String[] args) {
            //获取一个随机数
            //double d = Math.random();
            //System.out.println(d);
            
            //需求:我要获取一个1-100之间的随机数,肿么办?
            for(int x=0; x<100; x++) {
                int number = (int)(Math.random()*100)+1;
                System.out.println(number);
            }
        }
    }
    
    MathDemo.java

    GuessNumber.java

    /*
        猜数字小游戏(数据在1-100之间)
        
        分析:
            A:程序产生一个随机数。(被猜的)
            B:键盘录入数据。(你猜的)
            C:把你猜的和被猜的进行比较
                a:大了
                b:小了
                c:猜中了
            D:给出多次猜的机会,猜中就结束。
                while()循环,猜中就break
    */
    import java.util.Scanner;
    
    class GuessNumber {
        public static void main(String[] args) {
            //程序产生一个随机数。(被猜的)
            int number = (int)(Math.random()*100)+1;
            //System.out.println(number);
            
            //给出多次猜的机会,猜中就结束。
            while(true) {
                //键盘录入数据。(你猜的)
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入你要猜的数据(1-100):");
                int guessNumber = sc.nextInt();
                
                //把你猜的和被猜的进行比较
                if(guessNumber > number) {
                    System.out.println("你猜的数据"+guessNumber+"大了");
                }else if(guessNumber < number) {
                    System.out.println("你猜的数据"+guessNumber+"小了");
                }else {
                    System.out.println("恭喜你,猜中了");
                    break;
                }
            }
        }
    }
    
    GuessNumber

    3:代码块(理解)
        (1)用{}括起来的代码。
        (2)分类:
            A:局部代码块
                用于限定变量的生命周期,及早释放,提高内存利用率。
            B:构造代码块
                把多个构造方法中相同的代码可以放到这里,每个构造方法执行前,首先执行构造代码块。
            C:静态代码块
                对类的数据进行初始化,仅仅只执行一次。
        (3)静态代码块,构造代码块,构造方法的顺序问题?
            静态代码块 > 构造代码块 > 构造方法

    CodeDemo.java

    /*
        代码块:在Java中,使用{}括起来的代码被称为代码块。
        根据其位置和声明的不同,可以分为
            局部代码块:局部位置,用于限定变量的生命周期。
            构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前,都会先执行构造代码块。
                作用:可以把多个构造方法中的共同代码放到一起,对对象进行初始化。
            静态代码块:在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。
                作用:一般是对类进行初始化。
                
        面试题?
            静态代码块,构造代码块,构造方法的执行顺序?
            静态代码块 -- 构造代码块 -- 构造方法
            静态代码块:只执行一次
            构造代码块:每次调用构造方法都执行
    */
    class Code {
        static {
            int a = 1000;
            System.out.println(a);
        }
    
        //构造代码块
        {
            int x = 100;
            System.out.println(x);
        }
        
        //构造方法
        public Code(){
            System.out.println("code");
        }
        
        //构造方法
        public Code(int a){
            System.out.println("code");
        }
        
        //构造代码块
        {
            int y = 200;
            System.out.println(y);
        }
        
        //静态代码块
        static {
            int b = 2000;
            System.out.println(b);
        }
    }
    
    class CodeDemo {
        public static void main(String[] args) {
            //局部代码块
            {
                int x = 10;
                System.out.println(x);
            }
            //找不到符号
            //System.out.println(x);
            {
                int y = 20;
                System.out.println(y);
            }
            System.out.println("---------------");
            
            Code c = new Code();    
            System.out.println("---------------");
            Code c2 = new Code();
            System.out.println("---------------");
            Code c3 = new Code(1);
        }
    }
    
    //执行结果
    20
    ---------------
    2000
    200
    code
    ---------------
    200
    code
    ---------------
    200
    code
    
    CodeDemo.java

    StudentDemo.java

    package cn.itcast_02;
    
    /*
    写程序的执行结果。
    
    林青霞都60了,我很伤心
    我是main方法
    Student 静态代码块
    Student 构造代码块
    Student 构造方法
    Student 构造代码块
    Student 构造方法
    */
    class Student {
    static {
        System.out.println("Student 静态代码块");
    }
    
    {
        System.out.println("Student 构造代码块");
    }
    
    public Student() {
        System.out.println("Student 构造方法");
    }
    }
    
    class StudentDemo {
    static {
        System.out.println("林青霞都60了,我很伤心");
    }
    
    public static void main(String[] args) {
        System.out.println("我是main方法");
        
        Student s1 = new Student();
        Student s2 = new Student();
    }
    }
    
    StudentDemo.java

    4:继承(掌握)
        (1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系,
           这多个类就具备了这些内容。这个关系叫继承。
        (2)Java中如何表示继承呢?格式是什么呢?
            A:用关键字extends表示
            B:格式:
                class 子类名 extends 父类名 {}
        (3)继承的好处:
            A:提高了代码的复用性
            B:提高了代码的维护性
            C:让类与类产生了一个关系,是多态的前提
        (4)继承的弊端:
            A:让类的耦合性增强。这样某个类的改变,就会影响其他和该类相关的类。
                原则:低耦合,高内聚。
                耦合:类与类的关系
                内聚:自己完成某件事情的能力
            B:打破了封装性
        (5)Java中继承的特点
            A:Java中类只支持单继承
            B:Java中可以多层(重)继承(继承体系)
        (6)继承的注意事项:
            A:子类不能继承父类的私有成员
            B:子类不能继承父类的构造方法,但是可以通过super去访问
            C:不要为了部分功能而去继承
        (7)什么时候使用继承呢?
            A:继承体现的是:is a的关系。
            B:采用假设法
        (8)Java继承中的成员关系
            A:成员变量
                a:子类的成员变量名称和父类中的成员变量名称不一样,这个太简单
                b:子类的成员变量名称和父类中的成员变量名称一样,这个怎么访问呢?
                    子类的方法访问变量的查找顺序:
                        在子类方法的局部范围找,有就使用。
                        在子类的成员范围找,有就使用。
                        在父类的成员范围找,有就使用。
                        找不到,就报错。
            B:构造方法
                a:子类的构造方法默认会去访问父类的无参构造方法
                    是为了子类访问父类数据的初始化
                b:父类中如果没有无参构造方法,怎么办?
                    子类通过super去明确调用带参构造
                    子类通过this调用本身的其他构造,但是一定会有一个去访问了父类的构造
                    让父类提供无参构造
            C:成员方法
                a:子类的成员方法和父类中的成员方法名称不一样,这个太简单
                b:子类的成员方法和父类中的成员方法名称一样,这个怎么访问呢?
                    通过子类对象访问一个方法的查找顺序:
                        在子类中找,有就使用
                        在父类中找,有就使用
                        找不到,就报错
        (9)两个面试题:
            A:Override和Overload的区别?Overload是否可以改变返回值类型?
            B:this和super的区别和各自的作用?
        (10)数据初始化的面试题
            A:一个类的初始化过程
            B:子父类的构造执行过程
            C:分层初始化
        (11)案例:
            A:学生和老师案例
                继承前
                继承后
            B:猫狗案例的分析和实现
          ExtendsDemo.java

    /*
        继承概述:
            把多个类中相同的内容给提取出来定义到一个类中。
            
        如何实现继承呢?    
            Java提供了关键字:extends
            
        格式:
            class 子类名 extends 父类名 {}
            
        好处:
            A:提高了代码的复用性
            B:提高了代码的维护性
            C:让类与类之间产生了关系,是多态的前提
        
        类与类产生了关系,其实也是继承的一个弊端:
            类的耦合性增强了。
            
            开发的原则:低耦合,高内聚。
            耦合:类与类的关系
            内聚:就是自己完成某件事情的能力
    */
    
    //使用继承前
    /*
    class Student {
        public void eat() {
            System.out.println("吃饭");
        }
        
        public void sleep() {
            System.out.println("睡觉");
        }
    }
    
    class Teacher {
        public void eat() {
            System.out.println("吃饭");
        }
        
        public void sleep() {
            System.out.println("睡觉");
        }
    }
    */
    
    //使用继承后
    class Person {
        public void eat() {
            System.out.println("吃饭");
        }
        
        public void sleep() {
            System.out.println("睡觉");
        }
    }
    
    class Student extends Person {}
    
    class Teacher extends Person {}
    
    class ExtendsDemo {
        public static void main(String[] args) {
            Student s = new Student();
            s.eat();
            s.sleep();
            System.out.println("-------------");
            
            Teacher t = new Teacher();
            t.eat();
            t.sleep();
        }
    }

     ExtendsDemo2.java

    /*
        Java中继承的特点:
            A:Java只支持单继承,不支持多继承。
                有些语言是支持多继承,格式:extends 类1,类2,...
            B:Java支持多层继承(继承体系)
    */
    
    /*
    class Father {}
    class Mother {}
    class Son exnteds Father {} //正确的
    class Son extends Father,Mother {} // 错误的
    */
    
    class GrandFather {
        public void show() {
            System.out.println("我是爷爷");
        }
    }
    
    class Father extends GrandFather {
        public void method(){
            System.out.println("我是老子");
        }
    }
    
    class Son extends Father {}
    
    class ExtendsDemo2 {
        public static void main(String[] args) {
            Son s = new Son();
            s.method(); //使用父亲的
            s.show(); //使用爷爷的
        }
    }

    ExtendsDemo3.java

    /*
        继承的注意事项:
            A:子类只能继承父类所有非私有的成员(成员方法和成员变量)
            B:子类不能继承父类的构造方法,但是可以通过super(马上讲)关键字去访问父类构造方法。
            C:不要为了部分功能而去继承
                class A {
                    public void show1(){}
                    public void show2(){}
                }
                
                class B {
                    public void show2(){}
                    public void show3(){}
                }
                
                //我们发现B类中出现了和A类一样的show2()方法,所以,我们就用继承来体现
                class B extends A {
                    public void show3(){}
                }
                这样其实不好,因为这样你不但有了show2(),还多了show1()。
                有可能show1()不是你想要的。
                
        那么,我们什么时候考虑使用继承呢?
            继承其实体现的是一种关系:"is a"。
                Person
                    Student
                    Teacher
                水果
                    苹果
                    香蕉
                    橘子
                    
            采用假设法。
                如果有两个类A,B。只有他们符合A是B的一种,或者B是A的一种,就可以考虑使用继承。
    */
    class Father {
        private int num = 10;
        public int num2 = 20;
        
        //私有方法,子类不能继承
        private void method() {
            System.out.println(num);
            System.out.println(num2);
        }
        
        public void show() {
            System.out.println(num);
            System.out.println(num2);
        }
    }
    
    class Son extends Father {
        public void function() {
            //num可以在Father中访问private
            //System.out.println(num); //子类不能继承父类的私有成员变量
            System.out.println(num2);
        }
    }
    
    class ExtendsDemo3 {
        public static void main(String[] args) {
            // 创建对象
            Son s = new Son();
            //s.method(); //子类不能继承父类的私有成员方法
            s.show();
            s.function();
        }
    }

    ExtendsDemo4.java

    /*
        类的组成:
            成员变量:
            构造方法:
            成员方法:
        而现在我们又讲解了继承,所以,我们就应该来考虑一下,类的组成部分的各自关系。
        
        继承中成员变量的关系:
            A:子类中的成员变量和父类中的成员变量名称不一样,这个太简单。
            B:子类中的成员变量和父类中的成员变量名称一样,这个怎么玩呢?
                在子类方法中访问一个变量的查找顺序:
                    a:在子类方法的局部范围找,有就使用
                    b:在子类的成员范围找,有就使用
                    c:在父类的成员范围找,有就使用
                    d:如果还找不到,就报错。
    */
    class Father {
        public int num = 10;
        
        public void method() {
            int num = 50;
        }
    }
    
    class Son extends Father {
        public int num2 = 20;
        public int num = 30;
        
        public void show() {
            int num = 40;
            System.out.println(num);
            System.out.println(num2);
            // 找不到符号
            System.out.println(num3);
        }
    }
    
    class ExtendsDemo4 {
        public static void main(String[] args) {
            //创建对象
            Son s = new Son();
            s.show();
        }
    }

    ExtendsDemo5.java

    /*
        问题是:
            我不仅仅要输出局部范围的num,还要输出本类成员范围的num。怎么办呢?
            我还想要输出父类成员范围的num。怎么办呢?
                如果有一个东西和this相似,但是可以直接访问父类的数据就好了。
                恭喜你,这个关键字是存在的:super。
                
        this和super的区别?
            分别是什么呢?
                this代表本类对应的引用。
                super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)
    
            怎么用呢?
                A:调用成员变量
                    this.成员变量 调用本类的成员变量
                    super.成员变量 调用父类的成员变量
                B:调用构造方法
                    this(...)    调用本类的构造方法
                    super(...)    调用父类的构造方法
                C:调用成员方法
                    this.成员方法 调用本类的成员方法
                    super.成员方法 调用父类的成员方法
    */
    class Father {
        public int num = 10;
    }
    
    class Son extends Father {
        public int num = 20;
        
        public void show() {
            int num = 30;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(super.num);
        }
    }
    
    class ExtendsDemo5 {
        public static void main(String[] args) {
            Son s = new Son();
            s.show();
        }
    }

    ExtendsDemo6.java

    /*
        继承中构造方法的关系
            A:子类中所有的构造方法默认都会访问父类中空参数的构造方法
            B:为什么呢?
                因为子类会继承父类中的数据,可能还会使用父类的数据。
                所以,子类初始化之前,一定要先完成父类数据的初始化。
                
                注意:子类每一个构造方法的第一条语句默认都是:super();
    */
    class Father {
        int age;
    
        public Father() {
            System.out.println("Father的无参构造方法");
        }
        
        public Father(String name) {
            System.out.println("Father的带参构造方法");
        }
    }
    
    class Son extends Father {
        public Son() {
            //super();
            System.out.println("Son的无参构造方法");
        }
        
        public Son(String name) {
            //super();
            System.out.println("Son的带参构造方法");
        }
    }    
    
    class ExtendsDemo6 {
        public static void main(String[] args) {
            //创建对象
            Son s = new Son();
            System.out.println("------------");
            Son s2 = new Son("林青霞");
        }
    }

    ExtendsDemo7.java

    /*
        如果父类没有无参构造方法,那么子类的构造方法会出现什么现象呢?
            报错。
        如何解决呢?    
            A:在父类中加一个无参构造方法
            B:通过使用super关键字去显示的调用父类的带参构造方法
            C:子类通过this去调用本类的其他构造方法
                子类中一定要有一个去访问了父类的构造方法,否则父类数据就没有初始化。
                
        注意事项:
            this(...)或者super(...)必须出现在第一条语句上。
            如果不是放在第一条语句上,就可能对父类的数据进行了多次初始化,所以必须放在第一条语句上。
    */
    class Father {
        /*
        public Father() {
            System.out.println("Father的无参构造方法");
        }
        */
        
        public Father(String name) {
            System.out.println("Father的带参构造方法");
        }
    }
    
    class Son extends Father {
        public Son() {
            super("随便给");
            System.out.println("Son的无参构造方法");
            //super("随便给");
        }
        
        public Son(String name) {
            //super("随便给");
            this();
            System.out.println("Son的带参构造方法");
        }
    }
    
    class ExtendsDemo7 {
        public static void main(String[] args) {
            Son s = new Son();
            System.out.println("----------------");
            Son ss = new Son("林青霞");
        }
    }

    ExtendsDemo8.java

    /*
        继承中成员方法的关系:
            A:子类中的方法和父类中的方法声明不一样,这个太简单。
            B:子类中的方法和父类中的方法声明一样,这个该怎么玩呢?
                通过子类对象调用方法:
                    a:先找子类中,看有没有这个方法,有就使用
                    b:再看父类中,有没有这个方法,有就使用
                    c:如果没有就报错。
    */
    class Father {
        public void show() {
            System.out.println("show Father");
        }
    }
    
    class Son extends Father {
        public void method() {
            System.out.println("method Son");
        }
        
        public void show() {
            System.out.println("show Son");
        }
    }
    
    class ExtendsDemo8 {
        public static void main(String[] args) {
            //创建对象
            Son s = new Son();
            s.show();
            s.method();
            //s.fucntion(); //找不到符号
        }
    }

    ExtendsDemo9.java

    /*
        方法重写:子类中出现了和父类中方法声明一模一样的方法。
        
        方法重载:
            本类中出现的方法名一样,参数列表不同的方法。与返回值无关。
    
        子类对象调用方法的时候:
            先找子类本身,再找父类。
            
        方法重写的应用:
            当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法。
            这样,即沿袭了父类的功能,又定义了子类特有的内容。
            
        案例:
            A:定义一个手机类。
            B:通过研究,我发明了一个新手机,这个手机的作用是在打完电话后,可以听天气预报。
            按照我们基本的设计,我们把代码给写出来了。
            但是呢?我们又发现新手机应该是手机,所以,它应该继承自手机。
            其实这个时候的设计,并不是最好的。
            因为手机打电话功能,是手机本身就具备的最基本的功能。
            所以,我的新手机是不用在提供这个功能的。
            但是,这个时候,打电话功能就没有了。这个不好。
            最终,还是加上这个功能。由于它继承了手机类,所以,我们就直接使用父类的功能即可。
            那么,如何使用父类的功能呢?通过super关键字调用
    */
    class Phone {
        public void call(String name) {
            System.out.println("给"+name+"打电话");
        }
    }
    
    class NewPhone extends Phone {
        public void call(String name) {
            //System.out.println("给"+name+"打电话");
            super.call(name);
            System.out.println("可以听天气预报了");
        }
    }
    
    class ExtendsDemo9 {
        public static void main(String[] args) {
            NewPhone np = new NewPhone();
            np.call("林青霞");
        }
    }

    ExtendsDemo10.java

    /*
        方法重写的注意事项
            A:父类中私有方法不能被重写
                因为父类私有方法子类根本就无法继承
            B:子类重写父类方法时,访问权限不能更低
                最好就一致
            C:父类静态方法,子类也必须通过静态方法进行重写
                其实这个算不上方法重写,但是现象确实如此,至于为什么算不上方法重写,多态中我会讲解
                
            子类重写父类方法的时候,最好声明一模一样。
    */
    class Father {
        //private void show() {}
        
        /*
        public void show() {
            System.out.println("show Father");
        }
        */
        
        void show() {
            System.out.println("show Father");
        }
        /*
        public static void method() {
            
        }
        */
        
        public void method() {
            
        }
    }
    
    class Son extends Father {
        //private void show() {}
    
        /*
        public void show() {
            System.out.println("show Son");
        }
        */
        
        public void show() {
            System.out.println("show Son");
        }
        
        
        public static void method() {
        
        }
        
        /*
        public void method() {
        
        }
        */
    }
    
    class ExtendsDemo10 {
        public static void main(String[] args) {
            Son s = new Son();
            s.show();
        }
    }

    ExtendsTest.java

    /*
        看程序写结果:
            A:成员变量    就近原则
            B:this和super的问题
                this访问本类的成员
                super访问父类的成员
            C:子类构造方法执行前默认先执行父类的无参构造方法
            D:一个类的初始化过程
                成员变量进行初始化
                    默认初始化
                    显示初始化
                    构造方法初始化
                    
        结果:
            fu
            zi
            30
            20
            10
    */
    class Fu{
        public int num = 10;
        public Fu(){
            System.out.println("fu");
        }
    }
    class Zi extends Fu{
        public int num = 20;
        public Zi(){
            System.out.println("zi");
        }
        public void show(){
            int num = 30;
            System.out.println(num); //30
            System.out.println(this.num); //20
            System.out.println(super.num); //10
        }
    }
    class ExtendsTest {
        public static void main(String[] args) {
            Zi z = new Zi();
            z.show();
        }
    }

    ExtendsTest2.java

    /*
        看程序写结果:
            A:一个类的静态代码块,构造代码块,构造方法的执行流程
                静态代码块 > 构造代码块 > 构造方法
            B:静态的内容是随着类的加载而加载
                静态代码块的内容会优先执行
            C:子类初始化之前先会进行父类的初始化
            
        结果是:
            静态代码块Fu
            静态代码块Zi
            构造代码块Fu
            构造方法Fu
            构造代码块Zi
            构造方法Zi
    */
    class Fu {
        static {
            System.out.println("静态代码块Fu");
        }
    
        {
            System.out.println("构造代码块Fu");
        }
    
        public Fu() {
            System.out.println("构造方法Fu");
        }
    }
    
    class Zi extends Fu {
        static {
            System.out.println("静态代码块Zi");
        }
    
        {
            System.out.println("构造代码块Zi");
        }
    
        public Zi() {
            System.out.println("构造方法Zi");
        }
    }
    
    class ExtendsTest2 {
        public static void main(String[] args) {
            Zi z = new Zi();
            Zi z2 = new Zi();
        }
    }

    ExtendsTest3.java

    /*
        学生案例和老师案例讲解
        
        学生:
            成员变量;姓名,年龄
            构造方法:无参,带参
            成员方法:getXxx()/setXxx()
        老师:
            成员变量;姓名,年龄
            构造方法:无参,带参
            成员方法:getXxx()/setXxx()
    */
    //定义学生类
    class Student {
        //姓名
        private String name;
        //年龄
        private int age;
        
        public Student() {
        }
    
        public Student(String name,int age) {
            this.name = name;
            this.age = age;
        }
        
        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;
        }
    }
    
    //定义老师类
    class Teacher {
        //姓名
        private String name;
        //年龄
        private int age;
        
        public Teacher() {
        }
    
        public Teacher(String name,int age) {
            this.name = name;
            this.age = age;
        }
        
        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;
        }
    }
    
    class ExtendsTest3 {
        public static void main(String[] args) {
            //创建学生对象并测试
            //方式1
            Student s1 = new Student();
            s1.setName("林青霞");
            s1.setAge(27);
            System.out.println(s1.getName()+"---"+s1.getAge());
            
            //方式2
            Student s2 = new Student("林青霞",27);
            System.out.println(s2.getName()+"---"+s2.getAge());
            
            //对应的老师测试我不想了,留给你们自己练习。
        }
    }

    ExtendsTest4.java

    /*
        学生案例和老师案例讲解
        
        学生:
            成员变量;姓名,年龄
            构造方法:无参,带参
            成员方法:getXxx()/setXxx()
        老师:
            成员变量;姓名,年龄
            构造方法:无参,带参
            成员方法:getXxx()/setXxx()
            
        看上面两个类的成员,发现了很多相同的东西,所以我们就考虑抽取一个共性的类:
        人:
            成员变量;姓名,年龄
            构造方法:无参,带参
            成员方法:getXxx()/setXxx()
            
            学生 继承 人
            老师 继承 人
    */
    //定义人类
    class Person {
        //姓名
        private String name;
        //年龄
        private int age;
        
        public Person() {
        }
    
        public Person(String name,int age) { //"林青霞",27
            this.name = name;
            this.age = age;
        }
        
        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;
        }
    }
    
    //定义学生类
    class Student extends Person {
        public Student() {}
        
        public Student(String name,int age) { //"林青霞",27
            //this.name = name;
            //this.age = age;
            super(name,age);
        }
    }
    
    //定义老师类
    class Teacher extends Person {
    
    }
    
    class ExtendsTest4 {
        public static void main(String[] args) {
            //创建学生对象并测试
            //方式1
            Student s1 = new Student();
            s1.setName("林青霞");
            s1.setAge(27);
            System.out.println(s1.getName()+"---"+s1.getAge());
            
            //方式2
            Student s2 = new Student("林青霞",27);
            System.out.println(s2.getName()+"---"+s2.getAge());
            
            //补齐老师类中的代码并进行测试。
        }
    }

    ExtendsTest5.java

    /*
        猫狗案例讲解
        
        先找到具体的事物,然后发现具体的事物有共性,才提取出一个父类。
        
        猫:
            成员变量:姓名,年龄,颜色
            构造方法:无参,带参
            成员方法:
                getXxx()/setXxx()
                eat()
                palyGame()
        狗:
            成员变量:姓名,年龄,颜色
            构造方法:无参,带参
            成员方法:
                getXxx()/setXxx()
                eat()
                lookDoor()
                
        共性:
            成员变量:姓名,年龄,颜色
            构造方法:无参,带参
            成员方法:
                getXxx()/setXxx()
                eat()
                
        把共性定义到一个类中,这个类的名字叫:动物。
        动物类:
            成员变量:姓名,年龄,颜色
            构造方法:无参,带参
            成员方法:
                getXxx()/setXxx()
                eat()
                
            猫:    
                构造方法:无参,带参
                成员方法:palyGame()
            狗:
                构造方法:无参,带参
                成员方法:lookDoor()
    */
    //定义动物类
    class Animal {
        //姓名
        private String name;
        //年龄
        private int age;
        //颜色
        private String color;
        
        public Animal() {}
        
        public Animal(String name,int age,String color) {
            this.name = name;
            this.age = age;
            this.color = color;
        }
        
        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 String getColor() {
            return color;
        }
        
        public void setColor(String color) {
            this.color = color;
        }
        
        public void eat() {
            System.out.println("不要睡了,该吃饭了");
        }
    }
    
    //定义猫类
    class Cat extends Animal {
        public Cat() {}
        
        public Cat(String name,int age,String color) {
            super(name,age,color);
        }
        
        public void playGame() {
            System.out.println("猫玩英雄联盟");
        }
    }
    
    //定义狗类
    class Dog extends Animal {
        public Dog() {}
        
        public Dog(String name,int age,String color) {
            super(name,age,color);
        }
        
        public void lookDoor() {
            System.out.println("狗看家");
        }
    }
    
    //测试类
    class ExtendsTest5 {
        public static void main(String[] args) {
            //测试猫
            //方式1
            Cat c1 = new Cat();
            c1.setName("Tom");
            c1.setAge(3);
            c1.setColor("白色");
            System.out.println("猫的名字是:"+c1.getName()+";年龄是:"+c1.getAge()+";颜色是:"+c1.getColor());
            c1.eat();
            c1.playGame();
            System.out.println("---------------");
            
            //方式2
            Cat c2 = new Cat("杰瑞",5,"土豪金");
            System.out.println("猫的名字是:"+c2.getName()+";年龄是:"+c2.getAge()+";颜色是:"+c2.getColor());
            c2.eat();
            c2.playGame();
            
            //作业:测试狗
        }
    }

    面试题:

    /*
        看程序写结果:
            A:成员变量的问题
                int x = 10; //成员变量是基本类型
                Student s = new Student(); //成员变量是引用类型
            B:一个类的初始化过程
                成员变量的初始化
                    默认初始化
                    显示初始化
                    构造方法初始化
            C:子父类的初始化(分层初始化)
                先进行父类初始化,然后进行子类初始化。
                
        结果:
            YXYZ
            
        问题:
            虽然子类中构造方法默认有一个super()
            初始化的时候,不是按照那个顺序进行的。
            而是按照分层初始化进行的。
            它仅仅表示要先初始化父类数据,再初始化子类数据。
    */
    class X {
        
        X() {
            System.out.print("X");
        }
        Y b = new Y();
    }
    
    class Y {
        Y() {
            System.out.print("Y");
        }
    }
    
    public class Z extends X {
        
        Z() {
            //super
            System.out.print("Z");
        }
        Y y = new Y();
        public static void main(String[] args) {
            new Z(); 
        }
    }

    继承概述:

    首先我来写两个代码:
        //定义学生类
        class Student {
            String name;
            int age;
            
            public Student(){}
            
            //getXxx()/setXxx()
        
            public void eat() {
                System.out.println("吃饭");
            }
        }
        
        //定义老师类
        class Teacher {
            String name;
            int age;
            
            public Teacher(){}
            
            //getXxx()/setXxx()
            
            public void eat() {
                System.out.println("吃饭");
            }
        }
    我们观察上面两个代码:
        发现name,age成员变量,以及getXxx()/setXxx(),还有eat()等都是相同的。
        如果我们后来继续定义类,举例:工人类,军人类。他们是不是也具备这些内容。
        那么,我们每一次定义这样的类的时候,都要把这些重复的内容都重新定义一遍。
        麻烦不?麻烦。所以,我们要考虑改进?
    如何改进呢?
        我这想的:我能不能把这些相同的内容给定义到一个独立的类中。
        然后,让这多个类和这个独立的类产生一个关系,有了这个关系后,
        这多个类就可以具备这个独立的类的功能。
        为了实现这个效果,java就提供了一个技术:继承。
        
        父亲:
            4个儿子
    继承怎么表示呢?继承的格式是什么样子的呢?
        class Fu {}
        
        class Zi extends Fu {
            
        } 
        
    我们就回头修改我们的代码:
        class Person {
            String name;
            int age;
            
            public Person(){}
            
            //getXxx()/setXxx()
        
            public void eat() {
                System.out.println("吃饭");
            }
        }
        
        class Student extends Person {
            public Student(){}
        }
        
        class Teacher extends Person {
            public Teacher(){}
        }

    两个面试题:

    1:方法重写和方法重载的区别?方法重载能改变返回值类型吗?
    
    方法重写:
        在子类中,出现和父类中一模一样的方法声明的现象。
        
    方法重载:
        同一个类中,出现的方法名相同,参数列表不同的现象。
    
    
    方法重载能改变返回值类型,因为它和返回值类型无关。
    
    
    Override:方法重写
    Overload:方法重载
    
    2:this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。
    
    this:代表当前类的对象引用
    super:代表父类存储空间的标识。(可以理解为父类的引用,通过这个东西可以访问父类的成员)
    
    场景:
        成员变量:
            this.成员变量
            super.成员变量
        构造方法:
            this(...)
            super(...)
        成员方法:
            this.成员方法
            super.成员方法


           

  • 相关阅读:
    SQLMAP注入教程-11种常见SQLMAP使用方法详解
    VS2012/2013/2015/Visual Studio 2017 关闭单击文件进行预览的功能
    解决 IIS 反向代理ARR URLREWRITE 设置后,不能跨域跳转 return Redirect 问题
    Spring Data JPA one to one 共享主键关联
    JHipster 问题集中
    Spring Data JPA 定义超类
    Spring Data JPA查询关联数据
    maven命名
    maven仓库
    Jackson读取列表
  • 原文地址:https://www.cnblogs.com/super90/p/4869735.html
Copyright © 2011-2022 走看看