JAVA学习日记（八）

十六、集合

（一）集合和数组的对比：

集合可以自动扩容，数组长度固定。

集合可以存储引用数据类型不能直接存基本数据类型，数组都可以存储。

注：若集合要存储基本数据类型（byte，short，char，int......）则需要使用对应的包装类来代替

（二)集合对象构造方法：

格式：

ArrayList<泛型> list = new ArrayList<泛型>(); //泛型：限定集合中存储数据的类型

ArrayList<泛型> list = new ArrayList<>();

例子：

ArrayList<String> list = new ArrayList<>();
System.out.println(list);  //输出结果为 []
//ArrayList打印的对象不是地址值，是集合中存储数据内容，并且在打印时会用[ ]将所有数据进行包裹

（三）集合成员方法（增删改查）

例：

ArrayList<String> list = new ArrayList<>();

list.add("abc");
list.add("def");
list.add("ghi");
System.out.println(list.add("jkl"));   //输出为：true  add方法返回的是boolean类型的变量，无论添加什么元素都是返回true
System.out.println(list);   //[abc, def, ghi, jkl]

System.out.println(list.remove("abc"));  //输出为：true   remove方法返回的是boolean类型的变量
System.out.println(list.remove("fff"));  //输出为：false   括号内数据不存在于集合中就会返回false
System.out.println(list);  //输出为：[def, ghi, jkl]
System.out.println(list.remove(2));  //输出为：jkl   删除集合中索引为2的元素并且返回这个元素的值
System.out.println(list);  //输出为： [def, ghi]

System.out.println(list.set(1,"fuck"));  //输出为：ghi  修改集合中对应索引的元素值，并且将原来的元素值返回
System.out.println(list);  //输出为：[def, fuck]
System.out.println(list.get(1));  //输出为：fuck   根据索引返回集合中对应的元素值

System.out.println(list.size());  //输出为：2  返回集合的长度

十七、Static

静态变量：

用static来修饰类中的成员变量，称为静态变量：

特点：该类被所有对象共享，不属于对象而是属于类，随着类的加载而加载，优先于对象。

调用方式：类名调用（推荐）/ 对象名调用

public class Student {
        private String name;
        private String gender;
        private int age;

        public static String teachername;    //用static修饰
        public Student(){

        }

        public Student(String name,int age,String gender){
            this.name=name;
            this.age=age;
            this.gender=gender;
        }
}

内存中静态变量的出现是优先于对象的，静态变量是类的属性而不是创建的对象的属性（随着类的加载而出现，优先于对象）：

随后代码运行到new一个Student对象s1部分，在堆内存中开辟一个空间，将地址赋值给s1，地址指向的空间中是对象的初始值，若要调用这个Student类的静态变量teachername，则会访问静态存储位置：

随后通过s1的地址值，在运行到赋值代码时，通过指针修改地址对应的空间中的值name与age，打印数据时先调用成员方法show，再访问s1地址中的name与age，最后去访问静态存储位置的teachername：

创建新对象s2同理，开辟空间存储默认值，若后续调用teachername则需要去静态存储位置访问：

静态方法：

被static修饰的成员方法，称为静态方法

特点：多用在测试类和工具类中 JavaBean类中很少用

调用方式：如果是本类中调用，则可以直接方法名调用。如果是调用其他类，则用类名调用或者对象名调用。

例：工具类ArrayUtill中的静态方法printArr

工具类：帮助我们做一些事情但是不描述任何事物的类

特点：①类名见名知意 ②私有化构建方法 ③方法定义为静态

例：

静态方法注意事项：

①静态方法只能访问静态变量和静态方法

②非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法

③静态方法中是没有this关键词

重新认识main方法：

import java.util.ArrayList;

public class TestDemo {
    public static void main(String[] args) {
    }
}

public：被JVM(虚拟机)调用，访问权限足够大

static：被JVM调用，不用创建对象，直接类名访问。因为main方法是静态的，所以测试类中其他方法也必须是静态的。

void：被JVM调用，不需要给JVM返回值。

mian：一个通用的名称，虽然不是关键字，但是被JVM识别（主程序入口）。

String[] args：以前用于接受键盘录入数据的，现在没有用。

十八、继承

封装的不同类里面很多属性重复：

为这些重复的属性创建一个单独的地方存放（第三个类）成为父类：

格式：

Java中提供了一个关键字extends，用这个关键字，可以让一个类和另一个类建立起继承关系。

public class 子类 extends 父类 { }

例： public class Student extends Person { }

Student称为子类(派生类) Person称为父类(基类或超类）

继承的好处：

①可以把多个子类重复的代码抽取到父类中，提高代码复用性

②子类可以在父类的基础上，增加其他的功能，使其更功能强大。

当类和类之间，存在相同（共性）的内容，并满足子类是父类的一种，就可以考虑使用继承，来优化代码。

继承的特点：

Java只支持单继承，不支持多继承，但支持多层继承。

单继承：

一个类只能继承一个直接父类

多层继承：

子类A继承父类B，父类B可以继承父类C

C是A的间接父类，B是A的直接父类

每一个类都直接或间接的继承与Object类

子类只能访问父类中非私有的成员：

成员方法：

在满足非private修饰的前提下，子类能够继承父类中的方法。

而如果方法满足虚方法的前提，则子类在调用方法时不需要逐层返回父类去查询方法。

系统会生成一个虚方法表，每次继承都会继承父类的虚方法表，当子类调用的方法是虚方法时，可以直接在表中查询，但是如果调用的方法不是虚方法，则会逐层返回父类查询。

继承中成员变量的访问特点：

就近原则（先在局部内找，再从本类成员位置找，再从父类找，逐级向上。）

例：子类中有name，父类也有输出为子类name

public class animal {
    String name="动物";

}

public class Dog extends animal{
    String name="狗";
    public void watchhouse(){
        System.out.println("看家");
    }
    public void printname(){
        System.out.println(name);
    }
}


import java.util.ArrayList;

public class TestDemo {
    public static void main(String[] args) {
        Hashiqi dog1=new Hashiqi();
        dog1.printname();  //狗
    }
}

子类中没有，父类中有，输出为父类。

若都没有则会报错。

同时还可以用 this 和 super 关键字来解决变量重名

this（直接从本类成员开始逐级向上找）

super（直接从父类成员开始逐级向上找）

例：

public class Dog extends animal{
    String name="狗";
    public void watchhouse(){
        System.out.println("看家");
    }
    public void printname(){
        String name="狗狗狗";
        System.out.println(name);    //狗狗狗
        System.out.println(this.name);  //狗
        System.out.println(super.name);  //动物
    }
}

成员方法的调用同理

public class animal {
    String name="动物";
    public void eat(){
        System.out.println("吃饭");
    }
    public void drink(){
        System.out.println("喝水");
    }
}

public class Dog extends animal{
    String name="狗";
    public void watchhouse(){
        System.out.println("看家");
    }
    public void eat(){
        System.out.println("吃狗饭");
    }
    public void printeat(){
        this.eat();    //吃狗饭
        super.eat();    //吃饭
    }
}

方法的重写：

当父类中的方法不能满足子类现在的需求时，需要进行方法重写。

要求：

1、重写方法的名称、形参列表必须与父类中一致。

2、子类重写方法时，访问权限子类必须大于父类（空着不写<protected<pulic）。

3、子类重写父类方法时，返回值类型必须小于等于父类。

4、建议：重写的方法尽量和父类一致

5、只有被添加到虚方法表中的方法才能被重写。

书写格式：

在继承体系中，子类出现了和父类一样的方法声明，就称子类这个方法是重写的方法。

@Override重写注解

1、@Override是放在重写后的方法上，校验子类重写时语法是否正确。

2、加上注解后如果有红色波浪线，表示语法错误。

建议重写方法都加上@Override注解

例：

    @Override
    public void eat(){
        System.out.println("吃狗饭");
    }

方法重写的本质：

覆盖继承过来的虚方法表中对应的方法：

如下，B在继承父类C时，对方法2进行了重写，覆盖了继承时一并继承过来的虚方法表中的方法2.

A同样。

构造方法的访问特点：

1、父类中的构造方法不会被子类继承，但是可以通过super调用。

2、默认先访问父类的无参构造，再执行自己的。

（子类初始化前，一定会调用父类构造方法先完成父类数据空间的初始化）

子类构造方法的第一行语句默认为：super()，不写也存在，且必须在第一行。

3、如果子类想要调用父类有参构造，必须手动写super进行调用。

public class animal {
    String name="动物";

    public animal(){
        System.out.println("动物类的无参构造");
    }
}

public class Dog extends animal{
    String name="狗";
    public Dog(){
        //super();默认存在的代码，就算不写系统也会自动添加，且一定在第一行
        System.out.println("狗的无参构造");
    }
}


import java.util.ArrayList;

public class TestDemo {
    public static void main(String[] args) {
        Dog dog=new Dog();
    }
}

输出为：动物的无参构造
狗的无参构造

父类的带参构造：

例：

public class animal {
    String name;
    int age;
    public animal(){

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


public class Dog extends animal{

    public Dog(){
    }
    public Dog(String name,int age){
        super(name,age);
    }
}

import java.util.ArrayList;

public class TestDemo {
    public static void main(String[] args) {
        Dog dog=new Dog("bage",20);
        System.out.println(dog.name+","+dog.age);  //  输出为： bage,20
    }
}

this、super总结：

this：理解为一个变量，表示当前方法调用者的地址值；

super：代表父类存储空间。

this构造方法示例：

public class animal {
    String name;
    int age;
    public animal(){

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

public class Dog extends animal{

    public Dog(){
        this("狗",20);  //访问本类中的构造方法
    }
    public Dog(String name,int age){
        super(name,age);
    }
}


import java.util.ArrayList;

public class TestDemo {
    public static void main(String[] args) {
        Dog dog=new Dog();
        System.out.println(dog.name+","+dog.age);
    }
}

输出结果为：狗，20