黑马程序员技术交流社区

标题: java知识 [打印本页]

---

作者: 1634412491    时间: 2019-6-5 19:29
标题: java知识
1.继承
        什么是继承？
                如果一个类的对象 可以使用 另一个类的对象里的成员，这种关系就被称为继承

        继承的好处是什么？
                提高了代码的复用性
                让类与类之间产生了关系，这种是构成多态的前提条件

        继承的坏处是什么？
                因为类与类之间存在了关系，所以增加了耦合性

                开发原则提倡高内聚低耦合
                高内聚：自身功能越高越好
                低耦合：关系越少越好

        继承的格式？
                想要让两个类之间产生关系，要用关键字extends

                class Fu {

                }

                class Zi extends Fu {

                }

                Fu 父类
                Zi 子类

        java中类的继承特点？
                只支持单继承，不可以多继承，可以多层继承，不可以循环继承

        继承的注意事项？
                不能继承private修饰的成员
                构造方法不能继承

        我们什么时候可以使用继承呢？
                当两个类之间是"is a"的关系的时候，我们就可以让着两个类之间产生继承关系

                比如：
                        人类
                        学生类

                        人不一定是学生
                        学生肯定是人

                        所以他们之间可以使用继承，那谁继承谁呢？
                        学生 继承 人

                        动物类
                        猪类

                注：我们不能单单为了获取某一个功能而去随意的继承一个类
                        class Bird {
                                public void fly() {}
                        }

                        class Person extends Bird {

                        }

                        Person p = new Person();
                        p.fly();

        继承中子父类之间成员变量的特点？
                假设：父类中有一个成员变量，子类中有一个成员变量，子类的方法中有一个局部变量

                如果这三个变量的名字都不相同的话：
                        class Fu {
                                int i = 1;
                        }

                        class Zi extends Fu {
                                int j = 2;

                                public void print() {
                                        int x = 3;

                                        System.out.println(i);//1
                                        System.out.println(j);//2
                                        System.out.println(x);//3
                                }
                        }

                        public class Demo {
                                public static void main(String[] args) {
                                        Zi zi = new Zi();
                                        zi.print();
                                }
                        }

                如果这三个变量的名字都相同的话：
                        class Fu {
                                int i = 1;
                        }

                        class Zi extends Fu {
                                int i = 2;

                                public void print() {
                                        int i = 3;

                                        System.out.println(i);//3
                                        System.out.println(i);//3
                                        System.out.println(i);//3
                                }
                        }

                        public class Demo {
                                public static void main(String[] args) {
                                        Zi zi = new Zi();
                                        zi.print();
                                }
                        }
                       
                        从结果来看，打印的都是3，那怎么样能够分别打印1,2,3

                        class Fu {
                                int i = 1;
                        }

                        class Zi extends Fu {
                                int i = 2;

                                public void print() {
                                        int i = 3;

                                        System.out.println(i);//3
                                        System.out.println(this.i);//2
                                        System.out.println(super.i);//1
                                }
                        }

                        public class Demo {
                                public static void main(String[] args) {
                                        Zi zi = new Zi();
                                        zi.print();
                                }
                        }

        继承中子父类之间成员方法的特点？
                假设：父类中有一个成员方法，子类也有一个成员方法

                如果这两个方法的名字不相同的话：
                        class Fu {
                                public void printFu() {
                                        System.out.println("Fu");
                                }
                        }

                        class Zi extends Fu {
                                public void printZi() {
                                        System.out.println("Zi");
                                }
                        }
       
                        public class Demo {
                                public static void main(String[] args) {
                                        Zi zi = new Zi();
                                        zi.printFu();//Fu
                                        zi.printZi();//Zi
                                }
                        }

                如果这两个方法的名字相同的话：
                        class Fu {
                                public void print() {
                                        System.out.println("Fu");
                                }
                        }

                        class Zi extends Fu {
                                public void print() {
                                        System.out.println("Zi");
                                }
                        }
       
                        public class Demo {
                                public static void main(String[] args) {
                                        Zi zi = new Zi();
                                        zi.print();//Zi
                                        zi.print();//Zi
                                }
                        }

                        结果：打印的都是子类方法体中的内容，这里面不单单指的是就近原则，而是引出来一个新的知识点，名字叫做方法的重写，也叫做覆盖

                方法的重写？
                        什么是方法的重写？
                                在子父类继承中，子类中出现与父类方法的声明完全一致的方法，就被称为重写

                        重载和重写的区别？
                                重写：在子父类继承中，子类中出现与父类方法的声明完全一致的方法，就被称为重写
                                重载：在同一个类中，出现两个方法的名字相同，参数列表不同的两个方法，与返回值类型无关

                        我们在使用重写的时候需要注意哪些问题？
                                子类的重写方法的访问权限修饰符的权限要大于等于父类方法中的权限修饰符
                                子类的重写方法的返回值类型只能是父类方法的返回值类型的本身或者子类类型
                                子类不能重写父类中被private修饰的方法
                                子类不能重写父类中被final修饰的方法

                        我们为什么要使用重写？
                                因为使用了重写，编写代码更加灵活，既可以对功能进行延续，又可以对功能进行扩展

        继承中子父类之间构造方法的关系？
                        每一个构造方法的第一行都有一个默认的super()，前提第一行不是this()

                                class Person //extends Object {
                                        public Person() {
                                                //super();
                                        }
                                }

                                class Student extends Person {
                                        public Student() {
                                                //super();
                                        }
                                        public Student(String name) {
                                                //super();
                                        }
                                        public Student(int age) {
                                                //super();
                                        }
                                }

                        在同一个构造方法中，不能同时出现this()和super()

                        在一个类中，所有的构造方法中，至少有一个构造方法会有一个super(参数)

2.super关键字
        什么是super关键字？
                super是父类内存空间的标记，在用法上我们可以把它当做父类对象的引用使用，但是我们不能说它就是父类对象的引用

        this和super关键字的使用？
                this.成员变量
                super.成员变量

                this.成员方法()
                super.成员方法()

                this(参数)
                        调用本类中的构造方法
                super(参数)
                        调用父类中的构造方法

3.抽象类和抽象方法
        什么是抽象类？
                有抽象方法的类就是抽象类               

        什么是抽象方法？
                没有方法体的方法就是抽象方法

        抽象类和抽象方法的定义格式？
                public abstract Fu {
                        public abstract void eat();
                }

        抽象类的自身特点？
                抽象类和抽象方法必须有abstract关键字修饰
                抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类
                抽象类中有构造方法，但是不可以创建对象
                如果一个类想要继承抽象类，要么该普通类重写所有的抽象方法，要么它也是一个抽象类
       
目标：

能够写出类的继承格式?
        class Fu {
               
        }

        class Zi extends Fu {

        }

能够说出继承的特点？
        可以单继承，不可以多继承，可以多层继承，不可以循环继承

能够说出方法重写的概念？
        在子父类继承中，子类中出现一个方法，该方法的声明与父类的某一个方法的声明一致

能够说出super可以解决的问题？
        super可以调用父类的属性，成员方法，构造方法

描述抽象方法的概念？
        没有方法体的方法

写出抽象类的格式？
        abstract class AAA {

        }

写出抽象方法的格式？
        public abstract void aaa();

       

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2