目录
一、数组
1.1数组的初始化：
1.2数组的遍历方法：
1.3数组的常见使用方法：
二、类和对象
2.1构造方法：
2.2this关键字:
三、封装
3.1访问限定符：
3.2static关键字：
3.3代码块：
一、数组
1.1数组的初始化：
int[] arr={1,2,3,4};// 1 直接对数组初始化并含有初始值
int[] arr=new int[num];// 2 创建一个长度为num长度的数组，开始默认数组有num个0值
int[] arr=new int[]{1,2,3,4};// 3 初始化数组有四个值，系统会自动计算数组长度；
//二维数组初始化
int[][] arr={{},{},...,{}};// 4 与1类似
// 5 特别注意的是，二维数组有可能是不规则的，所以不能够new int[num][],否则会编译错误
可以new int[num1][num2],或者new int[][num];
int[][] arr=new int[][num];
//6 与一维数组的3类似
int[][] arr=new int[][]{{},{},...,{}};1.2数组的遍历方法：
常见的有两种：
//1.for each遍历数组，缺点是不能获得数组下标的值，优点是简洁
int[] arr={1,2,3,4};
for(int x:arr){ //x是把每一个arr数组的值给到x，再打印，类似python中的for循环
System.out.println(x);
}
//2.常见的for(int i=0;i<arr.length;i++)
//3.二维数组遍历
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
}
}1.3数组的常见使用方法：
1.升序排序 Arrays.sort(arr);
int[] arr={3,4,2,1};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));//{1，2，3，4}2.数组打印字符串 Arrays.toString(arr);
3.数组拷贝 int[] arr2=Arrays.copyOf(arr,arr.length)； //特别注意的是，copyOf还具有对数组扩容的功能,具体要扩容多少，就看给的第二个参数的多少；
int[] arr={3,4,2,1};
int[] arr2=Arrays.copyOf(arr,arr.length);
System.out.println(Arrays.toString(arr2));Arrays.copyOfRange(arr,from,to)； 这个方法可以决定拷贝数组的范围
int[] arr={3,4,2,1};
int[] arr2=Arrays.copyOfRange(arr,1,3);//范围是左闭右开
System.out.println(Arrays.toString(arr2));//输出结果为4,24.合并两个数组 使用System.arraycopy();
int[] arr1={1,2,3,4};
int[] arr2={5,6,7,8};
int[] arr=new int[arr1.length+arr2.length];
//其中第一个参数是源数组，也就是要复制的数组
//第二个参数是从源数组的起始位置，也就是要从哪个下标开始进行复制
//第三个参数是目标数组
//第四个参数是从目标数组的起始位置，也就是在目标数组的哪个索引下标开始放置复制的元素
//第五个参数是要从源数组复制元素的个数
System.arraycopy(arr1,0,arr,0,arr1.length);
System.arraycopy(arr2,0,arr,arr1.length,arr2.length);
//最终结果为{1，2，3，4，5，6，7，8}数组在Java中是如何存储的？
在Java虚拟机运行时数据区有5个：方法区，虚拟机栈，本地方法栈，堆，程序计数器
int[] arr={1,2,3,4};在这个数组中，arr是引用变量，存储在虚拟机栈中，如果我们直接输出的是arr，那么我们得到的结果就是这个数组的地址，而不是{1,2,3,4}；而数组的值{1,2,3,4}存放在堆中
二、类和对象
2.1构造方法：
作用就是对对象中的成员变量进行初始化，并不负责给对象开辟空间，如果用户没有显示定义，那么编译器会自动生成一个无参的构造方法；如果用户定义了有参构造方法，那么编译器自动生成的无参构造方法就会消失，再想调用无参构造方法的话，编译就会报错
class Dog{
public String name;
public int age;
//没有定义构造方法，但是编译器会自动生成一个无参的构造方法
//类似public Dog(){},就是一个无参的构造方法，
public Dog(String name, int age) { //定义了有参构造方法，编译器自动生成的无参就消失，
this.name = name;
this.age = age;
}
}
public class Test {
public static void main(String[] args) {
Dog dog1=new Dog();//编译器生成的无参构造消失，那么用实例化无参构造时就会报错
Dog dog2=new Dog("小黑",7);//显示定义有参构造方法，实例化正确
}
}2.2this关键字:
this关键字用在构造方法当中的第一条语句，如果不是第一条语句，就会报错
特别注意的是，使用this关键字时，避免形成环，
public Dog(){
this("小黑",7);
}
public Dog(String name, int age) { //定义了有参构造方法，编译器自动生成的无参就消失，
this(); //形成环，变成递归构造
this.name = name;
this.age = age;
}三、封装
3.1访问限定符：
有四个
private，私有权限，安全性最高，在同一个包同一个类中能访问
default，包访问权限，只能在同一个包下访问
protected，包子权限，在同一个包下能够访问，在不同包的子类能够访问
public，公共权限，所有都能够访问
如果想要访问私有权限，那么我们要通过公共的方法进行访问，也就是通过get和set方法访问到私有成员变量
class Dog{
private String name;
private int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Test {
public static void main(String[] args) {
Dog dog=new Dog("小黑",7);
System.out.println(dog.getName());//不能够直接访问dog.name，因为name是私有成员变量，只能通过getName()得到name的值，如果要设置name，那么可以通过setName方法修改
System.out.println(dog.getAge());
}
}3.2static关键字：
static修饰成员变量/方法，那么这就意味着这个成员变量已经不是对象所特有的，我们可以通过类名.变量能够访问，就算不实例化对象，一样可以访问到被static修饰的成员变量或者方法，被static修饰的成员变量/方法叫做类变量/类方法。
class Dog{
public static String name;
public int age;
public Dog(String name, int age) {
this.name=name;
this.age = age;
}
public static void Bark(String name){
System.out.println(name+"汪汪叫");
}
public void Sleep(String name){
System.out.println(name+"在睡觉");
}
}
public class Test {
public static void main(String[] args) {
Dog dog=new Dog("小黑",7);
System.out.println(Dog.name);//被static修饰，可以通过类名直接访问
Dog.Bark(Dog.name); //被static修饰，可以通过类名直接访问
dog.Sleep(Dog.name);//不被static修饰，只能通过对象dog访问
}
}特别注意的是，在被static修饰的方法中，也就是在静态方法中，不能够出现任何非静态方法因为非静态方法中有this引用；相反，在非静态成员方法中却可以出现静态方法。
public static void Bark(String name){
System.out.println(name+"汪汪叫");
Sleep(name); //错误，有非静态成员方法
}
public void Sleep(String name){
System.out.println(name+"在睡觉");
Bark(name); //正确
}如果在静态方法中非要用到非静态成员方法，只需要实例化对象，通过对象就可以访问到非静态成员方法了！
3.3代码块：
代码块有三种，静态代码块，实例代码块（构造代码块），普通代码块
静态代码块：用static定义的代码块，常用于初始化静态成员变量
实例代码块（构造代码块）：定义在类中的且不被修饰符修饰代码块，一般用于初始化实例成员变量
普通代码块：定义在方法中的代码块
public static String name;
public int age;
//静态代码块 1
static {
name="小红";
}
//实例代码块 2
{
this.age=9;
}
public Dog(int age) { //普通代码块 3
this.age = age;
}需要特别注意的是，如果实例化对象之后，代码块的访问顺序是1，2，3；如果连续两次实例化对象，那么代码块的访问顺序就是12323，原因就是静态代码块只会执行一次，用完一次之后就会消失，也就访问不到静态代码块啦！
