• java


    1.泛化(继承,实现)

    A is a B

    A有B的所有属性

    2.包含(组合,聚合,关联)

    A has a B

    B是A的一部分

    3.依赖

    A use a B

    A需要B才能实现

    继承:

    所有类都默认继承object类

    object中的方法:

    hashcode() 将内存地址计算得到一个整数, public native int hashcode(); native: 调用了底层c++语言的方法

    equals()      比较内容是否一致 publice boolean equals(object obj){ return this == obj;}

    toString()    把类的内容转化为String字符串

    getClass()   获取类的映射

    wait             线程等待

    notify           线程唤醒

    notifyAll       全部唤醒

    finalize         protected   类被垃圾回收器回收时调用

    clone            protected   克隆类对象

    子类可以继承父类的所有属性和方法,父类中的所有public属性和方法都可以直接使用,private的可以继承但是不能修改和直接使用。

    子类用 extends + 父类 继承

    每一个类只能继承一个类,让类变的更加安全。

    子类可以添加自己独特的属性和方法

    权限:public,protected,默认不写,private  从大到小

    子类的权限必须大于等于父类

    方法返回值:子类范围必须小于等于父类(子类返回值是person,父类返回值是animal)

    方法重写: 子类重写父类方法。名字参数一致

    方法重载:一个类中的相同名字的方法。 名字一致,参数必须不同

    特征标志符:父类中 final static abstract 修饰的方法

    final:子类不能重写

    static:子类不存在

    abstract: 子类必须重写

    构造方法:创建子类时会调用子类构造方法,也会调用父类的构造方法

    普通方法:子类调用方法时,优先寻找子类符合要求的方法,没有则寻找父类,再没有就寻找父类的父类。

    this.方法 ()      this指的是当前对象的方法,而不是this定义时的所在类。

    super.方法()    super指的是当前执行的对象的父类。

    this和super在构造方法中不能互相调用对方的构造方法。(this和super调用构造方法为this(),super(),且必须写在第一行)

    package Extends;
    
    public class People extends Animal{
        //构造方法
        public People(){
            System.out.println("People的构造方法");
        }
    
        public void test(){
            System.out.println("People的test");
        }
    
        public void show(){
            System.out.println("age = " + this.age);//this.name在子类中找不到因为是private,在父类中可以this.name使用。
        }
    
        public static void main(String[] args) {
            People p = new People();   //会运行Object,Animal People 3个类的构造方法
            p.test();                  //会优先运行p这个对象(是一个people)的方法,如果没有,则去父类寻找
            p.age = 11;
        }
    }
    package Extends;
    
    public class Animal {
    
        private String name;
        public int age;
    
        public Animal(){
            System.out.println("Animal的构造方法");
        }
    
        public void test(){
            System.out.println("Animal的test");
        }
    }

    2.包含(组合,聚合,关联)

    一个类中包含另一个类,那个类是这个类的一部分

    组合:一起出现,一起消亡。

    聚合:整体和部分的关系,创建时有可能分开。

    关联:整体和部分,可以分割,后来形成。

    高内聚:类内的属性方法只和自己关系密切

    低耦合:类和其他类互相影响小

    3.依赖

    一个类的方法中使用到了另一个类。

    可以使传参或者创建等操作。

    类的加载顺序:

    Animal

    Person extends Animal

    Person p = new Person();

    先加载静态

    先执行块

    先执行构造方法

    先父类

    1. 加载父类静态部分,执行静态块

    加载静态部分(方法区的静态元素区):空间,属性,方法,块

    执行静态块

    2. 加载子类静态部分,执行静态块

    加载静态部分(方法区的静态元素区):空间,属性,方法,块

    执行静态块

    3. 开辟对象空间(堆内存)

    4. 加载父类非静态部分:属性,方法,块,构造方法

    5. 执行父类块

    6. 执行父类构造方法

    7. 加载子类非静态部分:属性,方法,块,构造方法

    8. 执行子类块

    9. 执行子类构造方法

    10.空间地址赋给变量p

    附加:

    main会先加载自己所在的class的静态属性和块。

    静态部分加载时用到的非静态部分也会提前被加载,有可能比静态部分加载的早。

  • 相关阅读:
    2.1 CDN Bypass
    4.1 SQL Injection
    ztosec/secscan-authcheck 安装部署教程
    浏览器的内部构造
    左右值的概念
    网络安全学习路线
    Python+Typora博客图片上传
    微信欢乐五子棋辅助
    [SUCTF 2019]EasySQL
    [护网杯 2018]easy_tornado (SSTI)
  • 原文地址:https://www.cnblogs.com/clamp7724/p/11598658.html
Copyright © 2020-2023  润新知