java——数组以及基础类型，引用类型区别，浅拷贝深拷贝、javadoc文档 、 常量池

1.数组的初始化方式

1）静态初始化

String[] a={"1","2"};

2) 动态初始化

String[] b=new String[2];

2.数组的排序

sort

int[] a= {1,5,8,3,2,4,8,5,8,10,55,0};
Arrays.sort(a);
for (int b:a) {
            System.out.print(b+"\t");
        }

treeset

public class TreeSetDemo {
        public static void main(String[] args) {
                // 如果一个方法的参数是接口，那么真正要的是接口的实现类的对象
		// 而匿名内部类就可以实现这个东西
		TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
			@Override
			public int compare(Student s1, Student s2) {
				// 姓名长度
				int num = s1.getName().length() - s2.getName().length();
				// 姓名内容
				int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
						: num;
				// 年龄
				int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
				return num3;
			}
		});
 
		// 创建元素
		Student s1 = new Student("linqingxia", 27);
		Student s2 = new Student("zhangguorong", 29);
		Student s3 = new Student("wanglihong", 23);
		Student s4 = new Student("linqingxia", 27);
		Student s5 = new Student("liushishi", 22);
		Student s6 = new Student("wuqilong", 40);
		Student s7 = new Student("fengqingy", 22);
		Student s8 = new Student("linqingxia", 29);
 
		// 添加元素
		ts.add(s1);
		ts.add(s2);
		ts.add(s3);
		ts.add(s4);
		ts.add(s5);
		ts.add(s6);
		ts.add(s7);
		ts.add(s8);
 
		// 遍历
		for (Student s : ts) {
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}
}

3.数组的内存分配

栈内存：地址；指向堆内存的数据
堆内存：数组的数据

4.基础类型和引用类型

基础类型：

四型八种：整型，浮点型，布尔型，字符型

基本类型比较使用  ==    值比较
引用类型当使用 ==   地址比较
引用类型当值比较时： 使用equals方法

5.常量池

程序中的字面量，第一次执行时，会默认入池。
当使用这些字面量时，如未new，则直接返回该常量池中的对象地址

6.浅拷贝和深拷贝

浅拷贝：“=” 直接赋值地址，容易误改相同地址的变量（String除外，String为不可变类，每次变值都会自动新建一块堆内存）

浅拷贝误改变量值：

深拷贝：不但复制 栈 空间，还复制 堆 空间的内容

7。基础类型与引用类型之间的转换问题（性能消耗）

装箱
拆箱
Boxing，Unboxing
Boxing：基本类型变量 ==》 引用类型对象的转换过程
Unboxing：引用类型 ==》 基本类型

Boxing主要发生在：
基本类型 与 封装类(引用类型)
int i1 = 100 Integer i2 = i1
Integer i2 = Integer.valueOf(i1);
Integer i2 = new Integer(i1);

基本类型 与 字符串
int i1 = 100 String str1 = String.valueOf(100);

Unboxing主要发生在：
Integer i2 = new Integer(100); int i1 = i2;

8.对象数组

String a[]=new String[4];

for(int i=0;i<a.length;i++){
	String a[i]=new String();
	a.xxxxx=xxxxxx;
}

9.成员变量与局部变量的区别

成员变量自动赋初值，大多数为封装类；
局部变量需要初始化

10.函数的重载

函数名相同，参数表不同即可；

11.IDEA的ｊａｖａ文档生成

12.构造方法

当有了自己写的有参构造方法后，系统不会自动生成无参构造，需要自己加上无参构造

13.static、普通代码块、静态代码块

static：可以在对象声明前就类名调用静态方法或静态变量（方便）（先于对象）
类中的代码块：又可称为构造代码块

顺序：
静态变量初始化》静态初始化块》静态方法》（new实例化）
（new实例化）》变量初始化》初始化块》构造方法》方法

静态方法执行顺序：new对象之前就已经执行：静态变量初始化，静态初始化块和静态方法

继承执行顺序：父类静态变量和初始化块先于子类；
父类变量初始化，代码块，构造方法先于子类…

执行顺序：
父类静态变量初始化》父类静态初始化块》子类静态变量初始化》子类静态初始化块》父子类静态方法》（new实例化）
（new实例化）》父类变量初始化》父类初始化块》父类构造方法》子类变量初始化》子类初始化块》子类构造方法》方法

静态方法中 只能有静态变量（先于对象）
其他方法能调用静态变量或方法

普通代码块： 类似构造函数，每创建一个对象就执行一次，用作初始化；


静态代码块：只执行一次，先于所有方法，也可用于初始化；

14.封装

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏

封装不只是把客观事物封装成类，也包含对类的成员数据的封装
1.成员变量为私有 private类型
2.生成 ge/set方法供外界使用

	1）可在get中改变数据格式
	例如：只返回部分数据

	2)可在set中添加数据校验

15.继承

继承是指可以让某个类型的对象获得另一个类型的对象的属性的方法

父类的那些成员（属性、方法）会被子类继承，主要由修饰符决定。

this //对象类本身
super //父类

一般父类成员数据（成员变量）为私有型private；子类通过get/set方法取参传参；get/set方法为public型

父类方法的重写

*@Override 该注解是提供重写方法的方法名是否正确
*子类重写父类的方法，修饰符但作用域不能低于父类被重写方法的修饰符

16.final

> 1.修饰类   该类为不可变类，不可被继承extends
> 2.修饰方法   该方法不能被子类重写
> 3.修饰变量    改变量赋初值后不可被修改

17.is-A，has-A

is-A 代表类之间的继承关系,某对象是否是某类的实例。
has-A 代表类和对象从属关系，同一种类的对象，通过它们的属性的不同值来差别。

Object类和 is-A的用法

1）is-A的用法

obj instanceof A;
A.class.isInstance(obj);

2）Object 超类的主要用法

tostring()
一般是用于转换字符串格式，此处对自定义类进行重写修改数据格式

equals
引用型地址比较 ==
引用行值比较 equals

java中大部分官方类都重写了Object的equals方法；
自定义类是引用类型，其没有默认重写object类的equals方法；若想要完成自定义类的值比较，需要编程工具自动生成（类似set/get方法）

Master master=new Master();
Master master1=new Master();
System.out.println(master == master1);
System.out.println(master.equals(master1));

结果


hashCode
获取当前对象的哈希码值（无符号整数）
当两对象的equals为true时，hashCode值相同
当两对象的equals为flase时，hashCode值也不定不相同
故重写equals时也重写hashCode方法
当两对象的equals为true时，hashCode值相同
当两对象的equals为flase时，hashCode值不同
通过比较hashCode值比较判断是否相等

int i=master.hashCode();

clone
官方的类都重写了Object.clone()方法，所以可以正常的 深拷贝
自定义的类，默认不能完成深拷贝，需要重写clone()方法
使一个自定义类支持 深拷贝 需要完成以下操作：
1、重写超类的clone()方法，使用 alt + insert | alt + shift + s
2、使该类实现Cloneable接口

public class Master implements Cloneable{
    @Override
    protected Master clone() throws CloneNotSupportedException {
        return (Master) super.clone();
    }

//============================================
try {
    master1=master.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}

System.out.println(master == master1);
System.out.println(master.equals(master1));

结果：

18.