Java面向对象

继承

继承作用：多个实体类中存在很多重复的(属性,功能),提高代码复用性

继承的使用： 父类|基类|超类 : 子类的共性(属性,共性)

子类|派生类 : 对象的共性

子类 extends 父类

！！注意 : 继承为单继承机制,一个子类只能存在一个直接父类,但是一个父类可以存在多个子类

优点 : 简化结构,使用简单

缺点 : 不灵活,不便于后期维护

子类一旦继承父类,有权使用父类的成员

public class extends001 {
    public static void main(String[] args){
        Cat cat=new Cat();
        cat.run();


    }

}
class Animal{
    private String name;
    private String variety;

    public Animal(String name, String variety) {
        this.name = name;
        this.variety = variety;
    }

    public Animal() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getVariety() {
        return variety;
    }

    public void setVariety(String variety) {
        this.variety = variety;
    }
}
class Cat extends Animal{

    private int age;
    public void run(){
        System.out.println("一只"+getVariety()+"的猫在跑");
    }
   /* public Cat(String name, String variety, int age) {
        this.name = name;
        this.variety = variety;
        this.age = age;
    }
    */


    public Cat() {

    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
class Dog001 extends Animal{

    private String color;

    public Dog001() {
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

}

    extends 延续+扩展  

访问权限修饰符

访问权限修饰符：成员修饰符，只修饰成员，不修饰局部

private（私有的） 只能在当前类中访问

default（默认的，没有修饰符时默认为default） 当前类中，同包不同类

protected （被保护的） 当前类中，同包不同类，不同包的子类中(继承)

public  当前类中，同包不同类，不同包的子类中(继承)，不同包的其他类中

！！注意 : 能够修饰的类的访问权限修饰符 : public | default

                最常用的访问权限修饰符 : public | private

                面相对象设计原则之一 : 开闭原则 对修改关闭,对扩展开放

方法的重写

方法重写和方法重载的区别：

共同点：都是方法的特性

不同点：

重载Overload： 1.一个类中的多个方法 2.方法名相同 3.参数列表不同|方法签名不同

重写Override: 1.两个类中的两个方法 2.继承|实现关系 3.方法签名完全相同

使用重写的前提 :

当子类从父类中继承了功能,功能满意,功能实现不满意的时候,可以在子类中对这个继承的功能重新实现-->重写

调用 : 如果子类中存在重写方法,会调用子类中重写的方法,对父类中被重写的方法进行屏蔽

检测方法是否是重写方法 :

1.在重写方法的行号的后面存在提示显示 O↑

2.强制检测一个方法是否为重写方法 @Override

不能被重写的方法 :

1.private修饰的方法不能被重写 私有方法可以被继承,但是无权访问

2.被final修饰的方法不能被重写

3.静态方法不能被重写

！！如果子类中存在于父类静态方法同名的方法,要求子类中的这个方法也要为静态的

重写的实现要求 : == <= >=

1.==方法签名完全相等

2.<= 返回值类型

基本数据类型|void : 重写方法的返回值类型 == 被重写方法的返回值类型

引用数据类型 : 重写方法的返回值类型<=被重写方法的返回值类型（）

3.>= 重写方法的访问权限修饰符>=被重写方法的访问权限修饰符

public class Class001_Override {
    public static void main(String[] args) {
        SiCong siCong = new SiCong();
        siCong.words();
    }
}


class JianLin{
    //名言
    public JianLin words(){
        System.out.println("先定一个小目标,挣它一个亿...");
        return null;
    }
}

class SiCong extends JianLin{
    //重写 : 重新定义words的方法体
    @Override
    public SiCong words(){
        System.out.println("我不在乎我的朋友有钱没钱,反正全都没我有钱...");
        return null;
    }
}

super

super与this之间的区别： 都是关键字,都指代对象

super与this都不能使用在静态方法中

this：指代当前对象(new的对象|调用成员方法的对象)

1、构造器的首行,调用本类中的其他构造器 2、区分同名的变量问题(局部变量与成员变量)

super：指代父类对象

1、子类构造器的首行,通过super(实参)调用父类构造器

如果在子类构造器的首行没有显示调用父类指定构造器,默认调用父类空构造

2、在子类中区分子父类中同名成员问题(成员变量,成员方法)

如果存在子父类中同名成员,默认this.调用子类中的 通过super.调用父类同名成员

如果不存在同名问题,super.可以省略

子父类继承关系下创建子类对象 : 先父类后子类

final

final : 最终的 ！！被final修饰的变量为常量 ！！被final修饰的方法不能被重写 ！！被final修饰的不能被继承(太监类)

object

Object : 类 是java中所有类的父类（老祖宗类）

如果一个类没有显示的继承自其他类,默认继承自Object

在java中所有的类都会继承自Object类,因为不是直接继承,就是间接继承

toString : 返回对象的字符串表现形式

来自于Object类中toString方法的实现 :

当在java中输出一个对象的引用时候,默认输出的是对象调用了toString方法的返回值

结合业务,希望输出一个对象的引用 时候,想要输出的是这个对象的所有属性值,而非地址值

以后在定义实体类的时候,都应该根据所有的属性重写toString方法

    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

当在java中输出一个对象的引用时候,默认输出的是对象调用了toString方法的返回值

结合业务,希望输出一个对象的引用 时候,想要输出的是这个对象的所有属性值,而非地址值

以后在定义实体类的时候,都应该根据所有的属性重写toString方法

实体类的定义规范 | Javabean类的定义规范:

1.类是公共的

2.至少提供一个空构造,根据需求提供带参

3.属性私有化,提供一对公共的访问方式

4.根据所有属性值重写toString方法