JAVA学习笔记（2）

idea快捷键

在空的工程下新建Module(模块)

psvm快速生成

sout

IDEA自动保存不需要ctrl+s

ctrl+y删除一行

新增快捷键alt+insert

final关键字

1.表示最终的，不可变的

2.可以修饰变量、方法、类等

3.修饰的变量只能赋一次值

修饰的方法无法覆盖

修饰的类无法继承

修饰的引用一旦指向某个对象，则不能再重新指向其他对象，但该引用指向的的对象内部的数据是可以修改的

修饰的实例变量必须手动初始化，不能采用系统默认值

修饰的实例变量一般和static联合使用，称为常量

final class A{}
class C{
    final public void do(){
        
    }
}
class B{
    final double PI=3.14;
}

**final**只影响覆盖，不影响重载。(可以理解为覆盖会让子类中的该方法重写，只有一个，而重载是有多个，不会出现问题)

抽象类（类的进一步抽象）

如果父类的方法本身不需要实现任何功能，仅仅是未来定义方法签名，目的是让子类去覆写它，那么可以将父类的方法声明为抽象方法：

abstract class Person{
    public abstract void run();
}

抽象类无法创建对象，因为无法执行抽象方法，因此这个类也必须申明为抽象类（abstract class）。

无法实例化一个抽象类。抽象方法实际上相当于定义了“规范”，子类必须覆写其定义的抽象方法。

final 和 abstract不能联合使用，这两个关键字是独立的

抽象类的子类可以是抽象类也可以是非抽象类

抽象类不一定有抽象方法，但是抽象方法一定出现在抽象类中

一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆写

抽象类是引用数据类型

[修饰符列表] abstract class 类名{

}

抽象类的子类可以是抽象类

抽象类虽然无法实例化但是有构造方法，这个构造方法是供子类使用的

abstract class Account{
    public Account(){}
    public Account(String s){}
}
class CreditAccount extends Account{
    public CreditAccount(){
        super();
    }
}

接口

1.接口也是一种引用数据类型

2.接口是完全抽象的（方法不能有方法体），抽象类是半抽象的

3.定义语法

[修饰符列表] interface 接口名{

}

4.支持多继承

interface C extends A,B{
    
}

5.接口中只包含两部分内容，一部分是常量，一部分是抽象方法

接口中随便写一个变量就是常量

interface MyMath{
    public static final double PI=3.1415926;
    public abstract int sum(int a,int b);
}

6.接口中所有元素都是public修饰的，都是公开的

1. public abstract；public static final修饰符可以省略

interface MyMath{
    //常量
    double PI=3.1415926;
    //抽象方法
    int sum(int a,int b);  
}
class A implements MyMath{
    //public不能去掉，方法重写子类的访问权限只能更高，不能更低
    public int sum(int a,int b){
        return a+b;
    }
}

8.类和类之间叫做继承(extends)，类和接口之间叫实现（implements)。实现可以看成继承（也可以父类型的引用指向子类型的对象）接口和多态的联合使

1. 继承(extends)和实现(implements)同时存在。

   extends在前，implements在后

   public class Test04{
       public static void main(String[] args){
           Flyable cat=new Cat();//多态
           cat.fly();
       }
   }
   class Animal{
       
   }
   interface Flyable{
       void fly();
   }
   class cat extends Animal implements Flyable{
       public void fly(){
           System.out.println("aaa");
       }
   }

   接口通常提取的是行为动作

   接口在开发中的作用：类似于多态在开发中的作用（面向抽象编程，降低程序的耦合度，提高程序的扩展力）

   接口在开发中的作用：面向抽象编程可以修改为面向接口编程，可插拔表示扩展力很强。高扩展性，低耦合度。

   接口为什么离不开多态：达到解耦

   public class Test{
       public static void main(String[] args){
           //创建厨师对象
           FoodMenu cooker1=new ChinaCooker();
           //创建顾客对象
           Customer customer=new Customer(cooker1);
           //顾客点餐
           customer.order();
       }
   }
   //顾客
   public class Customer{
       private FoodMenu foodMenu;
       public Customer(){}
       public Customer(FoodMenu foodMenu){
           this.foodMenu=foodMenu;
       }
       public void setFoodMenu(FoodMenu foodMenu){
           this.foodMenu=foodMenu;
       }
       public FoodMenu getFoodMenu(){
           return foodMenu;
       }
       //点菜方法
       public void order(){
           foodMenu.shiZiChaoJiDan();
           foodMenu.yuXiangRouSi();
       }
   }
   //接口：菜单
   public interface FoodMenu{
       void shiZiChaoJiDan();
       void yuXiangRouSi();
   }
   //中餐厨师
   public class ChineseCooker implements FoodMenu{
       public void shiZiChaoJiDan(){
           System.out.println("中餐师傅做的西红柿炒鸡蛋！");
       }
       public void yuXiangRouSi(){
           System.out.println("中餐师傅做的鱼香肉丝！");
       }
   }
   //西餐厨师
   public class AmericCooker implements FoodMenu{
       public void shiZiChaoJiDan(){
           System.out.println("西餐师傅做的西红柿炒鸡蛋！");
       }
       public void yuXiangRouSi(){
           System.out.println("西餐师傅做的鱼香肉丝！");
       }
   }

   任何一个接口都有调用者和实现者。

   定接口的是架构师

   is a 继承关系；has a 属性关系；like a实现关系（类实现接口）

package和import机制

package+包名

package语句只能出现在源代码的第一行

编译：javac -d . HelloWorld.java

异常

异常在java中以类和对象形式存在

发生异常时会在底层创建一个异常对象

所有异常都是在运行时刻发生。编译时异常一般发生的异常的概率比较高

对于发生概率较高的异常，在编译阶段进行预处理

如果所以的异常都是在编写程序阶段进行预处理，程序会绝对安全，但是程序员太累，到处都是处理异常的代码。

两种方式

1.在方法声明的位置上使用throws关键字，抛给上一级（异常上抛）

2.使用try catch语句进行异常的捕捉（异常的捕捉）

异常发生后如果一直上抛，抛到main方法后，main抛给虚拟机，之后程序终止

public class ExceptionTest{
    //异常的继续上抛
    public static void main(String[] args)throws ClassNotFoundException{
        doSome();
    }
    public static void doSome() throws ClassNotFoundException{
        System.out.println("doSome!!!")
    }
}
​
​

public class ExceptionTest{
    //异常捕捉
    public static void main(String[] args)throws ClassNotFoundException{
        try{
          doSome();  
        }catch(ClassNotFoundException|FileNotFoundException e){
            //这个分支可以使用e引用，e引用保存的内存地址是那个new出来异常对象的内存地址。
            e.printStackTrace();
        }
    }
    public static void doSome() throws ClassNotFoundException{
        System.out.println("doSome!!!")
    }
}

不管怎样异常都需要处理，尤其是编译时异常，在编写阶段必须进行处理

而且抛的异常必须能处理其，可以抛其父类异常或者本身，抛其他的不行。实在不行抛Exception

一般不建议在main方法中继续throws，一般main方法中的异常使用try catch进行捕捉

只要异常没有捕捉，采用上报的方式，此方法后面的代码不会执行。

try语句块中的某一行出现异常，该行后面的代码不执行

捕捉异常之后，后续代码可以执行

多个catch异常，相当于if else语句，防止多次捕捉，从上到下，从小到大

空指针异常是运行时异常

方法才能抛异常，存在异常不抛不会有问题

异常的信息以异步的方式输出

exception.getMessage();//获取异常简单描述信息：这个信息实际上就是构造方法上面的String参数
exception.printStackTrace();//打印异常堆栈信息

查看异常的追踪信息：

从上往下看。

finally

一定执行且最后执行，通常使用在（1）流的关闭，且将流的声明放在try外面，同时需要判断语句

try中有return仍会执行finally中的语句。退出JVM之后就不执行了

try不能单独执行，但是可以和finally 一起执行，可以没有catch

final是一个关键字，修饰的变量表示最终的，finally使用在异常处理机制中，finalize（）是Object中的一个方法，由垃圾回收器GC调用的

自定义异常

1.继承Exception/RuntimeException

2.提供两个构造方法，一个无参的一个带有String类型的参数

public class MyException extends Exception{
    public MyException(){
        
    }
    public MyException(String s){
        super(s);
    }
}

程序中出现异常的地方都可以手动throw抛出异常，不return了

包装类

public class TestInteger {
 2 
 3     public static void main(String[] args) {
 4         // TODO Auto-generated method stub
 5        Integer i1=new Integer(123);
 6        Integer i2 = new Integer("123");
 7        System.out.println("i1=i2:"+(i1==i2));//false
 8        System.out.println("i1.equals(i2):"+i1.equals(i2));
 9        System.out.println(i2);
10        System.out.println(i2.toString());//说明重写了toString方法
11        Integer i3=new Integer(128);
12        System.out.println(i1.compareTo(i3));//-1
13        System.out.println(i1.compareTo(i2));//0
14        System.out.println(i3.compareTo(i2));//1
15        //(1)Integer-->int    包装对象.intValue()
16        int i=i1.intValue();
17        System.out.println(Integer.max(10, 20));//返回最大值
18        //(2)String -->int  包装类类名.parseInt(String s)
19        int ii=Integer.parseInt("234");
20        //(3)int -->Integer
21        Integer i4=Integer.valueOf(123);
22        //(4)int-->String
23        String str=ii+"";
24        String s=String .valueOf(ii);
25        //(5)String-->Integer;
26        Integer i5=new Integer("345");
27        //(6)Integer-->String
28        String ss=i5.toString();
29        System.out.println(ss);
30     }
31 
32 }

String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：

String类

.length（）方法返回长度

.concat()方法用于连接字符串

或者通过“+”连接

格式化字符串：fomat,priintf两种方式

System.out.printf("浮点型变量的值为"+"%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +"is %s", floatVar, intVar, stringVar);
​
String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);  

数组

datatype[] arrayRefVar//声明的首选方法

创建数组：arrayRefVar=new dataType[arraySize];

Java 数组

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，....，number99。

本教程将为大家介绍 Java 数组的声明、创建和初始化，并给出其对应的代码。

---

声明数组变量

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRefVar; // 首选的方法 或 dataType arrayRefVar[]; // 效果相同，但不是首选方法

注意: 建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自 C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。

实例

下面是这两种语法的代码示例：

double[] myList; // 首选的方法 或 double myList[]; // 效果相同，但不是首选方法

---

创建数组

Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事：

• 一、使用 dataType[arraySize] 创建了一个数组。

• 二、把新创建的数组的引用赋值给变量 arrayRefVar。

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

dataType[] arrayRefVar = new dataType[arraySize];

for(type element: array)
{
    System.out.println(element);
}

class TestIt
{
    public static void main ( String[] args )
    {
        int[] myArray = {1, 2, 3, 4, 5};
        ChangeIt.doIt( myArray );
        for(int j=0; j<myArray.length; j++)
            System.out.print( myArray[j] + " " );
    }
}
class ChangeIt
{
    static void doIt( int[] z ) 
    {
        z = null ;
    }
}

java 基本数据类型传递参数时是值传递 ；引用类型传递参数时是引用传递 。然而数组虽然是引用传递 ，但是将引用 z = null 只是将引用z不指向任何对象 ，并不会对原先指向的对象数据进行修改 。

访问权限

大小 public > protected >缺省 >private