JAVA初窥-DAY14

顺序表和链表

顺序表和链表的区别、数组和链表的区别、ArrayList和LinkedList的区别：
在增删改查四个方面去表述：
增：顺序表在增加元素的时候需要移动元素，链表只需要新建一个节点并改变上一个节点和此节点的next地址
删：顺序表在删除时也需要移动元素，而链表则只需要改变上一个节点的next地址
改：顺序表改变元素只需要通过下标或遍历找到需要修改的元素直接进行修改、链表改变节点需要遍历来找到节点再进行修改其val值
查：顺序表可以通过遍历来查找或者元素的下标直接进行查找，而链表则需要遍历来查询。

包

导所有代码中用到的包import java.util.*;
导入某个 如Scanner： import java.util.Scanner;
也可在代码中直接导入： java.util.Scanner scanner = new java.util.Scanner(System.in);
静态导入：import static java.lang.System.*;则代码中的打印为out.println();
在src下新建包的时候一般命名为域名如：com.baidu.src  / www   此处只是新建包（可以理解为在你的代码目录下新建文件夹）以此来区分一些相同名称的类，但不可用中文来命名，新建包后需要在代码文件的第一行加上类的地址如： packa com;（此类在com地址下）

包是组织类的一种方式，包可以保证类的唯一性。

访问限定修饰符

public：在所有类里都可以访问这个类里的普通成员变量。
protected：不同包中的子类可以访问。
private：只有在同一个包中同一个类才可以访问。
默认包访问权限：只有类在同一个包内，才能访问这个类里的普通成员变量。

范围	private	default	protected	public	备注
同一包中的同一类	1	1	1	1	在一个包里，且在一个类里
同一包中的不同类		1	1	1	在一个包里，同类不同类都可以访问
不同包中的子类			1	1	在不同的包里，但是是这个修饰符所修饰的类的子类也可以访问
不同包中的非子类				1	在不同包里，无任何关系也可以访问

面向对象与面向过程

什么是对象：由类实例化得到的就叫作对象->new
OOP:封装，使用private关键字，对普通成员变量或方法进行封装，在对外提供get与set方法
意义：数据的安全性提高，类的调用者对类使用的成本降低，只需要关注公开方法即可。
面向过程：就是注重过程，如：你想吃苹果，你需要先去买苹果，再洗苹果，再吃苹果。这一系列的操作就是过程。
面向对象：注重对象：如：你想吃苹果，交给保姆去做，直接等着吃苹果就好。这个保姆就是对象，只需要对对象下达指令即可。

继承

所有类的父类：Object，任何一个类都默认继承该类
有时创建的类之间有一定的联系，如：创建一个图片类，再创建一个人物图片类，再创建一个风景图片类。图类里有普通成员变量：颜色，名字，普通成员方法有，复制，删除。而这些方法和变量 在其他两个类里也有，但是其他两个类也有各自其他的变量和方法，则：

class Picture{
	public String name;
	public String color;
	
	public void copy(){
		System.out.println("此文件已复制！！")
	}
	public void delete(){
		System.out.println("此文件已删除！！")
	}
}


class PersonPicture extends Picture{
	public String person;
}
class SceneryPicture extends Picture{
	public String scenery;
}

则， picture就为父类，此时下面两个类继承了picture这个类的属性和方法。
A extends B的意思是 A是子类继承了B父类的方法和属性。
而A继承了B除了构造方法外的所有。
JAVA中只有单继承，就是某个子类只能继承于一个父类。
对于父类中private字段，子类中无法访问
Picture ：父类，基类，超类
PersonPicture/SceneryPicture：子类，派生类
继承的作用：代码的复用

super

this是当前对象的引用
this（DAY-08目录下封装及构造方法里）
super表示对父类对象的引用
super.data 显示或调用父类成员变量
super.func() 显示或调用父类的方法
在子类的构造方法中，super()表示对父类构造方法的调用
当父类构造方法没被调用时，子类的属性和方法均不能被调用，同样的super()在构造方法内只能放在第一行

class Picture{
    public String name;
    public String color;
    public Picture(String name){
        this.name = name;
    }
    public void copy(){
        System.out.println(name +"此文件已复制！！");
    }
    public void delete(){
        System.out.println(name +"此文件已删除！！");
    }
}
class PersonPicture extends Picture{
    public String person;
    public PersonPicture(String name,String person){
        super(name);
        this.person = person;
    }
}
class SceneryPicture extends Picture{
    public String scenery;
    public SceneryPicture(String name,String scenery) {
        super(name);
        this.scenery = scenery;
    }
}
public class Demo01 {
    public static void main(String[] args) {
        PersonPicture person = new PersonPicture("p2","lit");
        person.copy();
        SceneryPicture scenery = new SceneryPicture("p3","wind");
        scenery.delete();
    }
}

此时的执行顺序为：

父类Picture的静态代码块，
子类PersonPicture的静态代码块，
父类Picture的实例代码块，
父类Picture的构造函数，
子类PersonPicture的实例代码块，
子类PersonPicture的构造函数，

子类SceneryPicture的静态代码块，
父类Picture的实例代码块，
父类Picture的构造函数，
子类SceneryPicture的实例代码块，
子类SceneryPicture的构造函数。

final

在之前，我们就已经接触过final，但在当时final只是用来修饰常量，常量不可被修改，而final关键字也能修饰类，final修饰的类就不能被继承。不能被继承的类就叫密封类。而final还能修饰方法，这种方法被称为密封方法
一般情况下，继承不过三层。
当final修饰方法时，这个方法就叫密封方法，这个方法不能被重写
当final修饰变量，这个变量就是常量，常量不能被修改

组合

组合的关系：has a 或a part of

class Person{
public Man[] man;
public Woman[] woman;
}
class Man{
}
class Woman{
}

向上转型

把子类的对象给父类，父类的引用，指向了子类的实例
一般发生向上转型的情况有：赋值，方法传参，方法返回

class A{
    public int a = 1;
}
class B extends A{
    public int a = 2;
    public int b = 3;
}
public class Test{
    public static void main(String[] args){
        A a = new B();//向上转型  	B是子类，A是父类。
        System.out.println(a.a);//此时值为1，
        //System.out.println(a.b);此时报错，因为定义的是A父类的类型，而b是B类型特有的。 
    }
}

向下转型

不安全，容易出错，如果要进行向下转型，先要进行向上转型。

class A{
    public int a = 1;
}
class B extends A{
    public int a = 2;
    public int b = 3;
}
public class Test{
    public static void main(String[] args){
        A a = new B();//向上转型  	B是子类，A是父类。
        System.out.println(a.b);//编译出错，A类里没有b
		B b = (B)a;//向下转型
		System.out.println(b.a);//2
		System.out.println(b.b);//3
    }
}