java学习笔记

前言：以下主要为java学习过程中的笔记，没有顺序，想到什么就记录什么，因为是初学者，并且c和c++的基础不太好，如果有读者看见了错误请告知我，大恩不言谢。刚学习java的新手小白可以按照寻求自取哦，都是老师上课提到的一些重点，在java的学习过程中还是有帮助的，时不时可以翻出来看看，好记性不如烂键盘，🙏🙏🙏希望大家能一起努力变成一个优秀的程序员，与君共勉。

小白菜：
构造方法不能指明返回类型
静态方法只能调用静态成员变量
非静态方法可以调用静态变量，也可以调用非静态成员变量
静态方法可以使用类名.方法名进行调用
子类初始化时一定会先调用父类的构造方法

对象组合常见关系
1、 关联关系
类A关联类B的意思是，如果实例化一个A类的对象，同时，会有一个B类的对象被实例化。简言之，B作为A的属性存在。如下：

class A{
       private B b;
}
class B{
 
}

2、 依赖关系
类A依赖类B的意思是，如果A的对象要完成某一操作，必须使用B的对象的某些操作来帮忙，才能完成。简言之，B作为A的某个方法的方法参数存在。如下：

class A{
       public void f(B b){
        }
        }
       class B{
       }

一.super关键字作用

1：主要存在于子类方法中，用于指向子类对象中父类对象。

2：访问父类的属性

3：访问父类的函数

4：访问父类的构造函数

一，java初始化
注意：java数组是静态的，必须经过初始化后才可以使用，一但初始化数组长度，长度是不可以改变的。
1.静态初始化：初始化时由程序猿显示指定每个数组元素的初始值，由系统决定数组的长度
举例：
String[] names = new String[]{“孙猴子”,“唐僧”,“猪八戒”};
2.动态初始化：就是与静态初始化相对。其实动态初始化就是在初始化的时候指定数组长度（这时已经分配内存）
举例：

String[] names = new String[3];
names[0]=“孙猴子”;names[1]=“唐僧”;names[2]=“猪八戒”;

final关键字
常见的四种用法：
① 可以用来修饰一个类
② 可以用来修饰一个方法
③ 可以用来修饰一个局部变量
④ 可以用来修饰一个成员变量
1、final关键字用于修饰类
格式如下：
public final class 类名称 {
…
}
作用：使当前这个类不能有任何子类。（“太监类”）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写

2、final关键字用于修饰成员方法
格式如下：
修饰符 final 返回值类型 方法名称(参数列表) {
方法体
}
作用：当final关键字用来修饰一个方法的时候，这个方法就是最终方法，不能够被覆盖重写
注意：对于类、方法来说，abstract关键字和final关键字不能同时使用，因为作用相互矛盾

3、final关键字用于修饰局部变量
格式如下：
// ① 第一种基本数据类型情况下的格式
final 基本数据类型 数据名称 = 值;
// ② 引用数据类型情况下的格式
final 类型 对象名 = new 类名();
//例如：final Student stu = new Student();
作用：当final关键字用于修饰局部变量的时候，这个局部变量就不能更改，“一次赋值，终生不变”
注意：对于基本类型（int型、double型等）来说，不可改变指的是变量当中的数据不可改变，但是对于引用类型来说，不可改变的指的是变量当中的地址值不可改变。

4、final关键字用来修饰成员变量
对于成员变量来说，如果使用了final关键字修饰，那么这个变量也照样是不可变的
① 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了
② 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值，只能二选一
③ 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值

方法重载
方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。
方法重写
1.不能覆盖标识为final的方法，也不能覆盖不可被继承的方法。
2.子类的方法权限必须高于父类方法，或者说父类中的方法在子类中必须可见。如父类中的方法属性为private，子类可以继承而不可覆盖。访问权限由高到低：public、protected、包访问权限(默认)、private。
3.子类和父类的方法必须是实例方法。如果父类方法和子类方法都是static方法，子类隐藏父类而非覆盖。如果父类方法和子类方法有一个是静态方法，编译器会报错。
4.子类和父类的方法必须要具有相同的函数名称、参数列表，并且子类的返回值与父类相同或者是父类返回类型的子类型。如果方法名称相同而参数列表不同（返回类型可以相同也可以不同），那么只是方法的重载，而非重写。如果方法名称和参数列表相同，返回值类型不同，子类返回值类型也不是父类返回值类型的子类，编译器就会报错。
5.子类方法不能比父类方法抛出更多的编译时异常（不是运行时异常），即子类方法抛出的编译时异常或者和父类相同或者是父类异常的子类。当然，子类也可以不抛出异常，或者抛出 RuntimeException 异常不能覆盖标识为final的方法，也不能覆盖不可被继承的方法。

abstract（抽象类）关键字
A.抽象类和抽象方法必须使用abstract修饰
B.抽象类中不一定有抽象方法，但是有抽象方法的类必须定义为抽象类，即抽象类中包含抽象方法和非抽象方法。
C.抽象类不能实例化
a:抽象类具有构造方法，但是不能实例化。
D.抽象的的子类
a:如果不想重写所有方法，则可将该子类定义为一个抽象类，即如果一个abstract类是abstract类的子类，它可以重写父类当中任意的方法，也可以继承父类中所有的方法。
b:重写所有的的抽象方法，子类可以是一个具体的类，即一个非abstract类是abstract类的子类，则它必须重写父类的abstract方法，也就是将父类中的abstract方法去掉abstract修饰，并给出方法体。
E.抽象类里的抽象方法
a:抽象方法里没有实际的方法体。
即如果对抽象类（含有抽象方法）的子类，可以定义成抽象类也可以定义成具体类，如果定义成具体类，就要重写父类abstract中的所有抽象方法。
注：接口的实现中实现类要实现（重写）接口类中所有的方法

子类继承父类的静态方法：
1.子类重写父类静态方法，变为非静态方法会报错。
2.静态方法不能被覆盖。但是子类可以重新定义父类的静态方法，并将父类的静态方法屏蔽掉.
3.子类是可以使用父类的静态方法和静态变量的
4.子类可以继承父类的静态方法和静态变量，可以当做全局变量可以去使用（父类类名.方法）
5.子类可以继承父类静态属性和静态方法，但是不可以重写父类的静态方法而表现多态性
PS:前提是父类的静态方法对子类是可见的。
eg：父类方法不被private修饰

异常处理：
运行时异常可以不处理。
非运行时异常必须处理
try…catch…finally语句catch捕捉到了异常就会跳出来，直接运行finally之后的语句。

throw和throws
throws：用来声明一个方法可能产生的所有异常，不做任何处理而是将异常往上传，谁调用我我就抛给谁。
注：用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常
throw：则是用来抛出一个具体的异常类型。
注：用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理（catch）
throw是抛出了异常，执行throw则一定抛出了某种异常

equals 方法是 java.lang.Object 类的方法。
用法说明：
（1）对于字符串变量来说，使“==”和“equals()”方法比较字符串时，其比较方法不同。
“= =”比较两个变量本身的值，即两个对象在内存中的首地址。
“equals()”比较字符串中所包含的引用是否相同。
equals在String（继承了Object）类中被重写了，在String类中比较的是字符串的内容是否相同

一.java中的compareto方法

1.返回参与比较的前后两个字符串的asc码的差值，如果两个字符串首字母不同，则该方法返回首字母的asc码的差值

　 String a1 = "a";
        String a2 = "c"；
        System.out.println(a1.compareTo(a2));//结果为-2

2.即参与比较的两个字符串如果首字符相同，则比较下一个字符，直到有不同的为止，返回该不同的字符的asc码差值，

　　　　　String a1 = "aa";
        String a2 = "ad";
        System.out.println(a1.compareTo(a2));//结果为-3

3.如果两个字符串不一样长，可以参与比较的字符又完全一样，则返回两个字符串的长度差值

　　String a1 = "aa";
        String a2 = "aa12345678";
        System.out.println(a1.compareTo(a2));//结果为-8

4.返回为正数表示a1>a2, 返回为负数表示a1<a2, 返回为0表示a1==a2；

5.数字类型不能用compareTo，int跟int的比较不能用compareTo方法,直接用大于(>) 小于(<) 或者 等于(==) 不等于(!=)来比较即可

　　　　int num1 = 4;
        int num2 = 5;
       num1.compareTo(num2); 

你可以先把你的int型变量转换成String再进行比较

int num1 = 4;
int num2 = 5;
System.out.println((num1+"").compareTo(num2+""));//-1        
 System.out.println(new Integer(num1).toString(). compareTo(new Integer(num2).toString()));//-1        
       System.out.println(String.valueOf(num1).compareTo(String.valueOf(num2)));//-1

compareTo封装在comparable类里，是comparable类中唯一的方法，要想实现自定义的对象比较必须实现comparable接口，重写其比较方法，但通常可以在Arrys类中去调用编译器给的比较方法去比较我们想比较的对象

public class Test2{
String name; 
   int age;  
   public String toString(){        return "我的姓名是："+name+"\t我的年龄是："+age;}    public static void main(String[] args){Test2 Myclass    =    new    Test2();Myclass.name    =    "小明";
   Myclass.age        =    20;
System.out.println(Myclass);    //直接使用对象名时默认调用该对象的toString方法System.out.println(Myclass.toString());//手动调用String方法    }

toString返回该对象的字符串表示：
在JAVA中，所有的对象都有toString方法；
创建类时没有定义toString方法，输出对象时，会输出对象的哈希值；
它只是sun公司开发java的时候为了方便所有类的字符串操作而特意加入的一个方法
它通常只是为了方便输出：
例如：

public class Test2{
String name;    int age;    public String toString(){        return "我的姓名是："+name+"\t我的年龄是："+age;
}    public static void main(String[] args){
Test2 Myclass    =    new    Test2();
Myclass.name    =    "小明";
Myclass.age        =    20;
System.out.println(Myclass);    //直接使用对象名时默认调用该对象的toString方法
System.out.println(Myclass.toString());//手动调用String方法    }

如果类中没有定义toString方法，按照以上案例调用时，会输出对象的哈希值。
当我们打印一个对象的引用时，实际是默认调用这个对象的toString()方法
当打印的对象所在类没有重写Object中的toString()方法时，默认调用的是Object类中toString()方法。返回此对象所在的类及对应的堆空间对象实体的首地址值（哈希值）
当我们打印对象所在类重写了toString()，调用的就是已经重写了的toString()方法，一般重写是将类对象的属性信息返回。
其中几个包装类也是重写了toString()方法哒，使用包装类输出的时候会自动调用其中重写的toString()方法。

重写equals()和重写hashCode()
1.重写equals方法是为了比较两个不同对象的值是否相等
2.重写hashCode是为了让同一个Class的两个具有相同值的对象的Hash值相等。
3.同时重写hashCode()与equals()是为了满足HashSet、HashMap等此类集合的相同对象的不重复存储。

再来回顾一下数组的内容
1.数组的输出的三种方式

一维数组：

定义一个数组 int[] array = {1,2,3,4,5};

（1）传统的for循环方式

for(int i=0;i<array.length;i++)
{
      System.out.println(array[i]);
}

（2）for each循环

for(int a:array)
    System.out.println(a);

（3）利用Array类中的toString方法

调用Array.toString(a)，返回一个包含数组元素的字符串，这些元素被放置在括号内，并用逗号分开

int[] array = {1,2,3,4,5};
System.out.println(Arrays.toString(array));

输出：[1, 2, 3, 4, 5]

说明：System.out.println(array);这样是不行的，这样打印是的是数组的首地址。

二维数组：

对于二维数组也对应这三种方法，定义一个二维数组：

 int[][]magicSquare =
    	 {
    		 {16,3,2,13},
    		 {5,10,11,8},
    		 {9,6,7,3}
    	 };

Java实际没有多维数组，只有一维数组，多维数组被解读为"数组的数组"，例如二维数组magicSquare是包含{magicSquare[0]，magicSquare[1]，magicSquare[2]}三个元素的一维数组，magicSqure[0]是包含{16,3,2,13}四个元素的一维数组，同理magicSquare[1]，magicSquare[2]也一样。即二维数组是其中的元素为一维数组的一维数组。

（1）传统的for循环方式

for(int i=0;i<magicSquare.length;i++)
     {
    	 for(int j=0;j<magicSquare[i].length;j++)
    	 {
    		 System.out.print(magicSquare[i][j]+" ");
    	 }
    	 System.out.println();	//换行
     }

 

（2）for each循环

for(int[] a:magicSquare)
     {
    	 for(int b:a)
    	 {
    		 System.out.print(b+" ");
    	 }
    	 System.out.println();//换行
     }

（3）利用Array类中的toString方法

for(int i=0;i<magicSquare.length;i++)
    System.out.println(Arrays.toString(magicSquare[i]));

父类的protected成员是包内可见的，并且对子类可见；
若子类与父类不在同一包中，那么在子类中，子类实例可以访问其从父类继承而来的protected方法，而不能访问父类实例的protected方法。
即在不同包中，子类中new的对象可以访问继承来的protected方法，但在子类中，new的父类对象不可以访问实力中的protected方法，因为后者是因为在不同包中权限不过，而前者是因为该方法被子类继承了，相当于是在子类中了。