【Java】java基础2（数组||类||继承&多态&接口）

数组

数组转字符串输出

 public static void main(String[] args) {
        //数组转字符串
        int[] arr={1,2,4,5,6};
        String newarr= Arrays.toString(arr);
        System.out.println(newarr);
    }

数组拷贝

下面介绍三种数组拷贝方法

  public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        int[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("newArr: " + Arrays.toString(newArr));

        // 拷贝某个范围.
        int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);//左闭右开
        System.out.println("newArr2: " + Arrays.toString(newArr2));

        int[] newArr3=new int[arr.length*2];
        System.arraycopy(arr,0,newArr3,0,arr.length);
        System.out.println(Arrays.toString(newArr3));
        }

前两种调用了Arrays类中的方法，最后一种调用了系统本地方法（底层使用C/C++实现）完成数组的扩容+拷贝。

类的构造

    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();//静态代码块是否还会被执行？
    }
    }

class Person{
    private String name;//实例成员变量
    private int age;
    private String sex;
    private static int count = 0;//静态成员变量 由类共享数据 方法区
    public Person(){
        System.out.println("I am Person init()!");
    }
    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    //静态代码块
    static {
        count = 10;//只能访问静态数据成员
        System.out.println("I am static init()!");
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。

继承

class Animal{
    public String name;
    public  int age;
    public  String color;

    public void eat(){
        System.out.println(name+"正在吃");
    }

    public void bark(){
        System.out.println(name+"正在叫");
    }
}

class Dog extends Animal{
}

class Cat extends Animal{
}

继承是一种is a的关系，关键字为extend
如果要访问父类的a，则使用super关键字

default继承是同一个软件包下的所有类均可使用
protected继承是不同包的子类可以使用

final关键字

• 1.修饰变量或字段，表示常量（不能被修改）
• 2.修饰类，表示此类不能被继承

多态

通俗来说就是多种形态，具体来说是当多个对象调用同一种方法，会产生出不同的结果。在面向对象语言中，接口的多种不同的实现方式即为多态。

多态的条件

• 子类必须继承父类
• 子类必须重写父类方法（子类重写方法的访问权限不能低于父类）
• 父类引用指向子类对象

向上转型

直接赋值（父类引用指向子类对象）
方法传参（函数参数为父类引用，传的参数为子类对象）
方法返回（返回父类对象，实则对应子类对象的实例）

向上转型的应用：减少代码的逻辑判断（圈复杂度）

package demo1;

public class Test {
    public static void main(String[] args) {
       DrawMaps();
    }


    public static void DrawMaps(){
        Cycle cycle=new Cycle();
        Rect rect=new Rect();
        Flower flower=new Flower();

        Shape[] shapes={cycle,rect,cycle,rect,flower};//发生向上转型
        for(Shape s:shapes){
            s.draw();
        }
    }
}

class Shape{
    public void draw(){

    }
}

class Cycle extends Shape{
    public void draw(){
        System.out.println("○");
    }
}

class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("□");
    }
}
class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("♣");
    }
}

instanceof 可以判定一个引用是否是某个类的实例. 如果是, 则返回 true. 这时再进行向下转型就比较安全了。

抽象类

• abstract关键字表示，只能用于继承，不能实例化出对象。
• abstract修饰的类方法必须是public。
• 抽象类实际上利用编译器的校验功能，使我们在开发过程中能尽早发现问题。

接口

接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量.
使用 interface 定义一个接口，接口中的方法一定是抽象方法, 因此可以省略 abstract
接口中的方法一定是 public, 因此可以省略 public。
使用 implements 继承接口. 此时表达的含义不再是 “扩展”, 而是 “实现”
在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例.
接口不能单独被实例化
接口中的成员变量默认是public static final
接口中的成员方法默认是public abstarct

1.我们创建接口的时候, 接口的命名一般以大写字母 I 开头.
2. 接口的命名一般使用 “形容词” 词性的单词.
3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性

克隆方法的实现

package demo2;

class Person implements Cloneable{
    public int age;
    public Person(int age){
        this.age=age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }
}
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person p1=new Person(10);
        Person p2=(Person) p1.clone();
        System.out.println(p1);
        System.out.println(p2);
    }
}

实现类的方法必须implements native的cloneable接口，同时必须处理异常。这些在IDE环境都能联想生成。