Java暑期学习Day18

马太效应

今天是第18天，希望能用理解的方式长期地记忆

                               
登录/注册后可看大图

继承语法细节

A.被声明为protected的成员，相同包中的类可以直接存取，不同包中的类可以在继承后的子类直接存取。
B.依权限从小至大来区分，就是private、无关键字（默认）、protected、public。
C.使用super关键字调用的父类方法，不能定义为private（因为这限定只能在类中使用。）

<div><b>
//父类
class SuperClass {

        // public SuperClass(){
        // System.out.println("SuperClass的无参构造器");
        // }
        public SuperClass(String x) {
                System.out.println("SuperClass的构造器");
        }

}

// 子类

class subClass extends SuperClass {

        subClass() {
                // 默认会调用父类无参数构造器
                super("bear");
                System.out.println("subClass的构造器");
        }

}

// Super 关键字
public class SuperDemo {

        public static void main(String[] args) {
                /*
                 * this 当前对象 super 当前对象的父类对象
                 * 
                 * 应用场景：
                 * 
                 * 1.在子类方法中，调用父类被隐藏的方法</b></div><div><b>2.在子类方法中，返回父类被隐藏的成员变量</b></div><div><b>3.在子类方法中，调用父类的构造器
                 */

                // 创建子类对象
                subClass sub = new subClass();

        }

}</b>
</div>

结果是：
SuperClass的构造器
subClass的构造器

//动物类
class Animall {
        private String name;
        private int age;

        Animall(String name, int age) {
                this.name = name;
                this.age = age;
        }

        public void say() {
                System.out.println(this.name + "," + this.age);
        }

        public void sayHi() {

        }
}

// 鱼
class Fish extends Animall {
        private String color;// 颜色

        Fish(String name, int age, String color) {
                // this.name = name;
                // this.age = age;
                super(name, age);
                this.color = color;
        }

        //
        public void say() {
                super.say();
                System.out.println("我的年龄是：" + color);
        }

        // 检查方法是否为覆盖方法
        @Override
        public void sayHi() {

        }
}

public class SuperDemo2 {

        public static void main(String[] args) {

                Fish f = new Fish("小维尼熊", 2, "红色");
                f.say();

        }

}

结果是：
小维尼熊,2
我的颜色是：红色


D.重新定义（Override）方法时要注意，对于父类中的方法权限，子类只能扩大不能缩小。


E.static方法属于类拥有，如果子类中定义了相同签署的static成员，该成员属于子类所有，而非重新定义，static方法也没有多态，因为对象不会个别拥有static成员。


F.构造函数可以重载，父类中可重载多个构造函数，如果子类构造函数中没有指定执行父类中哪个构造函数，默认会调用父类中的无参数构造函数。


G.在Java中，子类只能继承一个父类，如果定义类时没有使用extends关键字指定继承任何类，那就意味着继承java.lang.object。

<div>import java.util.Arrays;


public class ArrayList {

        private Object[] list;                                          //使用Object数组收集
        private int next;                                               //下一个可存储对象的索引
        
        public ArrayList(int capacity){//指定初始容量
                
        int capasity=0;
                list=new Object[capasity];
        }
        
        public ArrayList(){
                this(16);    //初始容量默认为16
        }

public void add(Object o){                                    //收集对象方法
        if(next==list.length){                                              //自动增长Object数组长度</div><div>list=Arrays.copyOf(list,list.length*2);
                }</div><div>
        list[next++]=o;
        }
        
        public Object get(int index){                                          //依照索引取得收集的对象
                return list[index];
        }
        public int size(){                                         //已收集的对象个数
                return next;
        }

}
</div>

lang                       adj.<苏格兰>长的，很久的，冗长的;

object                            n.物体; 目标; 宾语; 客体，对象;
                                      vi.不赞成，反对; 抱反感;
                                      vt.提出…作反对的理由;


capacity                n.容量; 性能; 才能; 生产能力;
                           adj.充其量的，最大限度的;


resolved             adj.下定决心的，断然的; 坚决的; 已解决的;
                             v.做决定，分解(resolve的过去式和过去分词);


variable               adj.变化的，可变的; [数] 变量的; [生] 变异的;
                             n.可变因素，变量; 易变的东西;