Java学习笔记（一） - 《Java 基础》

（一）开发入门
(二)编程基础
1、Java关键字（50个）：

（一）开发入门

1、Java变量命名的规则：

·变量名可以以字母、下划线、美元符’$’为开头，不能以数字开头
·后跟数字、字母、下划线、美元符
·Java变量对于长度没有限制

2、什么是JDK（Java的三大体系：EE企业版 SE标准版 ME平台微型版）

·JDK全称为Java开发环境
由··Java编译器
··Java运行工具
··Java文档生成工具
··Java打包工具 四部分组成

·JRE为Java运行环境（）
··JRE工具只包含Java运行工具，而不包括Java编译工具（所以JRE为Java程序的运行环境）

3、Java目录介绍

·bin目录：存放一些可执行程序：javac.exe（Java编译器）、java.exe（Java运行工具）、jar.exe（打包工具）
javadoc.exe（文档生成工具）
·db目录：db目录是一个小型的数据库（Java成员Java DB）
·include目录: JDK是通过c和c++实现的，所以需要引入c的一些头文件（所以include库是用来存放c的头文件的）
·jre目录：Java运行环境时的根目录，包含Java虚拟机、运行时的类包、Java应用启动器、bin目录，但是不包含开发环境中的开发工具。
·lib目录：Java类库或者库文件，是开发工具使用的归档文件
·javafx-src.zip：该压缩文件内存放的是Java FX(Java图形用户界面工具)所有核心库类的源代码
·src.zip：为src的压缩文件，放置是JDK核心类的源代码，通过此文件可以查看Java基础类的源代码
·README等说明性文档：存放着很多的可执行性程序，最重要的就是javac.exe和ava.exe
··javac.exe是Java编译器工具，可以将写好的文件编译成可执行的Java文件（文件后缀有.java变化成.class）
··java.exe是Java运行工具，它会穷的那个一个Java虚拟机进程（Java虚拟机相当于一个虚拟的服务器），专门运行后缀为.class的可执行文件

4、系统环境变量：

·PATH环境变量：告知操作系统到指定的路径去寻找JDK
·CLASSPATH环境变量：用于告知JDK到指定路径去寻找类文件（.class文件）

5、Java的运行机制

·编写源文件001.java
·使用javac 001.java命令开启Java编译器进行编译
·编译结束后，产生一个001.class的字节码文件
·使用Java 001.java命令启动Java虚拟机将编译好的字节码文件加载到内存，这个过程称之为类加载，由类加载器完成，然后虚拟机通过Java解析器对加载到内存中的Java类进行解释执行
·执行完内后会产生计算机可以识别的机器码文件
·机器码文件在计算机运行并且显示结果

(二)编程基础

1、Java关键字（50个）：

2、变量的作用域

变量是先定义在使用的，但是可以不使用已经定义的变量
1、局部变量：定义在函数内部
生存周期和作用域都是在函数内部
2、成员变量：在类体中定义的变量也被称为属性
生存期是在对象的生存期
作用域是类内部的成员函数

3、运算符的优先级：数字越小优先级越大

4、数组的定义方法

·一维数组：
·· 数组类型[] 数组名 = new 数组类型 [数组长度]
·· 数组类型 [] 数组名 = new 数组类型 [] {数组元素0，数组元素1，……，数组元素n}
·· 数组类型 [] 数组名 = {数组元素0，数组元素1，……}

int[] str1 = new int[3];
int[] str2 = new int[]{1,2,3};
int[] str3 = {1,2,3};

·多维数组：
·· int [][] arr = new int[3][4]
·· int[][] arr = int[3][] //可以不标列，但是要标行
·· int[][] arr = {{1,2},{3,4,5,6},{7,8,9}}

int[][] arr = new int[3][4];
int[][] arr = new int[3][];
int[][] arr = {{1,2,3},{1,2,3},{1,2}}

（三）面向对象—-上

1、类与对象的关系

·类：类是对象的抽象，是描述一组对象共同的特征和行为
·对象：是对类的实例化

类的定义格式

[修饰符] class类名[extends 父类名][implements 接口名]{
        类体//包括包括成员变量和成员函数
    }

2、访问修饰符public、protected、private的区别（当一个类或者一个类的成员没有使用任何修饰符，则默认为friendly修饰符）

访问范围	同一个类中	同一个包中	子类中	其他包间
public	可以使用	可以使用	可以使用	可以使用
portected	可以使用	可以使用	可以使用
friendly	可以使用	可以使用
private	可以使用

3、方法的重载（作用于同一个类当中）

方法的重载：方法名相同，参数个数或者参数类型不同

public static int add(int x,int y){
    return x+y;
}
public static int add(int x,int y,int z){
    return x+y+z;
}
public static int add(double x,double y){
    return x+y;
}

4、构造方法的定义和重载

·构造方法的定义：
··方法名与类名相同
··方法名在没有返回值类型的声明
··方法中不能使用return返回一个值，但是可以单独使用return语句来作为方法的结束

class Person{
    public Person{
        system.out.println("调用了无参的构造方法")；  //还可以定义有参数的构造函数
    } 
}

·构造方法的重载：

class Person{
    String name;
    int age;
    public Person(int a){
        age = a;
    }
    public Person(String n,int a){    //上面的两种方法完成了对构造方法的重载
        name = n;
        age = a;
    }
    public void speak(){
        System.out.println("我今年"+age+"岁了！");
    }
    public void say(){
        Sysout.out.println("我叫"+nane+"，我今年"+age+"岁了");
    }
}
public class Examole1{
    public (String args[]){
        Person p1 = new Person(18);
        Person p2 = new Person("张三"，30);
        p1.speak();
        p2.say();
    }
}

5、this关键字

3种常见的用法
1、通过this关键字调用成员变量，解决与局部变量名称冲突问题。

class Person{
    int age;           //定义成员变量age
    public Person(int age){      //定义局部变量age
        this age = age;     //将局部变量age的值赋给成员变量age
    }
}

2、通过this关键字调用构造函数

class Person{
    public Person(){
        Sysout.out.println("无参的构造方法被调用了")；
    }
    public Person(int age){
        this();    //调用了无参的构造函数
        Sysout.out.println("有参的构造函数被调用了")；
    }
}
public class Example2{
    public static void main(String []args){
        Person p = new Person(18);
    }
}
//当this调用了有参的构造函数时，传值即可

3、通过this关键字调用成员方法

class Person{
    public void openMouth(){
        ......
    }
    public void speak(){
        this.openMonth;
    }
}

··this关键字注意点：
···只能在构造方法中使用this调用其他的构造方法，不能再成员方法中使用
···在构造方法中，使用this调用构造方法的语句必须在该方法的第一条执行语句，且只能出现一次
···不能在一个类的两个构造方法中使用this关键字相互调用

6、static关键字（修饰成员变量、成员方法以及代码块[定义的属性、类、方法都会直接加载到方法区]）

·静态变量：

static 变量类型  变量名    //静态变量的定义方法
类名.变量名     //静态变量的访问方式

·静态方法

class Person{
    public static void say(){
        Sysout.out.println("Hello!!!");
    }
public class Example3{
        public static void main(String[] args){
            Person.say();    //用“类名.方法名”调用静态方法
        }
        Person person = new Person();
        person.say();        //用“对象名.方法名”调用静态方法    
    }
}

·静态代码块:

static{
    ......
}

7、final关键字

·final修饰的类不能被继承

final calss Animal{        //final修饰的Animal类
}
class Dog extends Animal{    //此时Dog类继承Animal类，编译器会报错
}

·final修饰的方法不能被子类重写

class Animal{
    public final shout(){     //用final修饰的方法
    }
}
class Dog extends Animal{
    public void shout(){      //此时重写方法，编译器会报错
    }
}
public class Example04{
    public static void main(String[] args){
        Dog dog = new Dog();
    }
}

·final修饰的变量是常量，只能进行一次赋值
8、static关键字与final关键字的区别
static关键字：
final关键字：

（四）面向对象—-下

1、面向对象的三大特性：封装、继承、多态

2、**继承：

子类会自动拥有父类所有可继承的属性和方法

[修饰符] class 子类名 extends 父类名{
    //核心代码块
}                //继承的使用方式

class Animal{        //定义父类
    String name;
    void shout(){        //定义name属性
        Sysout.out.println("动物发出叫声！");
    }
}
public Dog extends Animals{        //声明Dog类继承Animal类
    public void printName(){
        Sysout.out.println("name"+name);
    }
}
public class Example4{             
    piblic static void main(String[] args){
        Dog dog = new Dog();        //实例化
        dog.name= "沙皮狗";        //调用父类的属性
        dog.printName();        
        dog.shout();        //调用父类的方法
    }
}

··注意点：
···类只允许单继承、不允许多重继承====>一个类只能由一个直接父类
···多个类可以继承同一个父类
···多层继承是允许的====>一个类的父类可能是另一个类的子类

3、重写和重载的区别（异同比较）

重写：存在于继承关系中，子类继承父类中公共的方法，但有时子类会对父类进行一些修改，即为对父类方法的重写
注意点：子类中重写的方法需要有与父类相同的方法名、参数列表、返回值类型

class Animal{
    void shout(){
        System.out.println("动物发出叫声！");
    }
}
class Dog extends Animal{
    void shout(){
        System.out.println("汪汪...");
    }    
}
public class Example5{
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.shout();
    }
}

重载：在一个类中定义多个同名的方法，但是每个方法参数的个数或者参数类型不同
注意点：方法的重载与返回值类型无关，只需满足方法名相同、参数个数或者参数类型不同即可

public class sum{
    public static int add(int x,int y){
        return x+y;
    }
    public static int add2(int x,int y,int z){
        return x+y+z;
    }
    public static double add3(double x,double y){
        return x+y;
    }
    public static void main(String[] args){
        int sum =add(1,3);
        int sum2 =add2(5,4,6);
        double sum3 =add3(1.4,2.4);
        System.out.println("sum="+sum);
        System.out.println("sum2="+sum2);
        System.out.println("sum3="+sum3);
    }
}

4、super关键字：当子类重写父类的方法后，子类对象将无法直接访问父类被重写的方法

···使用super关键字调用父类的成员变量和成员方法

super.成员变量
super.成员方法([参数1，参数2])

class Animal{
    String name="动物";
    void shout(){
        System.out.println("动物发出叫声");
    }
}
class Dog extends Animal{
    String name ="犬类";
    void shout(){
        super.shout();            //访问父类的成员方法
    }
    void pringName(){
        System.out.println("name="+super.name);            //访问父类的成员变量
    }
}
public class jiCheng{
    public static void main(String[] args){
        Dog dog = new Dog();            
        dog.shout();            //调用重写的shout（）方法
        dog.pringName();        
    }
}

···使用super关键字调用父类的构造方法

super(参数1，参数2，...)

class Animal{
    public Animal(String name){            //定义构造方法
        System.out.println("我是一只"+name);
        }
    }
class Dog extends Animal{
    public Dog(){
        super("沙皮狗");         //调用父类的构造方法
    }
}
public class jiCheng02{
    public static void main(String[] args){
        Dog dog = new Dog();    //创建子类Dog的实例对象
    }
}

注意点：super调用父类的构造方法时必须位于子类构造方法的第一行，并且只能出现一次

5、Object类：

object类是所有类的父类，通常被叫为超类、基类和跟类

6、抽象类和接口

抽象类：定义一些方法来描述该类的行为特征，但有时有些实现方法是无法确定的

[修饰符] abstract class 类名{        //定义抽象类
    [修饰符] abstract 方法返回值类型 方法名(参数列表){        //定义抽象方法
        方法体
    }
}

注意点：包含抽象方法的类必须定义为抽象类，但抽象类中可以不包含任何的抽象方法。
抽象类不可被实例化

abstract class Animal{          //定义抽象类
    public abstract void shout();        //定义抽象方法
}
class Dog extends Animal{
    public void shout(){
        System.out.println("汪汪...");        //子类实现抽象方法
    }
}
public class chouxiangLei{
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.shout();
    }
}

接口：一个抽象类中的所有方法都是抽象的，JDK8后，定义接口除了抽象方法还有默认方法[用default修饰]、
静态方法（类方法）[用static修饰]

[修饰符] interface 接口名 [extends 父接口1，父接口2]{
    [public][static][final] 常量类型 常量名 =常量值;
    [public] [abstract] 方法返回值类型 方法名([参数列表]){
    };        //定义抽象方法
    [public][default] 方法返回值类型 方法名([参数列表]){
    };            //定义默认方法
    [public][statuc] 方法返回值类型 方法名 ([参数列表]){
    }            //定义静态方法
}

注意点：接口可以定义多个常量和方法，但是定义常量时必须完成初始话赋值，定义默认方法和静态方法可以有多个方法体

interface Animal{            //定义接口Animal
    int ID = 1;                //定义全局变量ID
    void breathe();            //定义抽象方法breathe
    default void getType(String type){        //定义默认方法
        System.out.println("该动物属于"+type );        
    }
    static int getID(){            //定义静态方法
        return Animal.ID;
    }
}
interface LandAnimal extends Animal{        //LandAnimal接口继承接口
    void run();
}
class Dog implements LandAnimal{            //定义Dog类实现接口LandAnimal
    public void run(){
        System.out.println("狗在陆地上跑");        //实现抽象方法run()
    }
    public void breathe(){                        //实现抽象方法breathe()
        System.out.println("狗在呼吸");
    }
}
public class jieheJie{
    public static void main(String[] args){
        System.out.println(Animal.getID());            //在接口中只能使用类名调用静态方法
        Dog dog =  new Dog();
        System.out.println(dog.ID);
        dog.breathe();
        dog.getType("犬科");
        dog.run();
    }
}

ps：静态方法在类中可以使用类名.静态方法名和对象名.静态方法名调用静态方法，而在接口中不能使用对象调用静态方法，只能使用接口名.静态方法名调用静态方法

注意点：接口实现类的实例化对象可以直接访问接口中的常量、接口实现方法以及默认方法。
静态方法则要使用接口名调用
接口的实现类必须实现接口中的所有抽象方法，否则程序编译报错

7、**多态：

是指不同类的对象在调用同一个方法时所呈现出的多种不同方法，在一个类中定义的属性和方法在被其他类继承或重写后，当把子类对象直接赋值给父类引用变量时，相同引用类型的变量所呈现的多种不同形态

abstract class Animal{          
    abstract void shout();
}
class Cat extends Animal{
    public void shout(){
        System.out.println("喵喵...");
    }
}
class Dog extends Animal{
    public void shout(){
        System.out.println("汪汪...");
    }
}
public class duoTai{
    public static void main(String[] args){
        Animal an1 = new Cat();        //子类cat对象向上转型为父类Animal
        Animal an2 = new Dog();        //子类dog对象向上转型为父类Animal
        an1.shout();
        an2.shout();
    }
}

多态存在的条件：·子类继承父类（无继承无多态）
·子类重写父类方法（无覆写无多态）
·创建一个子类的实例向上转型为父类

向上转型：将子类对象当作父类类型使用(是安全的，不会出现错误)

注意点：向上转型不能通过父类变量去调用子类特有的方法

Animal an1 = new Cat();        //子类cat对象向上转型为父类Animal
Animal an2 = new Dog();        //子类dog对象向上转型为父类Animal

abstract class Animal{
    abstract void shout();
}
class Cat extends Animal{
    public void shout(){
        System.out.println("喵喵...");
    }
    public void catchMouse(){
        System.out.println("小猫抓老鼠");
    }
}
public class Xiangshang{
    public static void main(String[] args){
        Animal an1 = new Cat();            //错误写法
        Cat cat =(Cat)an1;                // Animal an1 = new cat();
        cat.shout();                    // an1.shout();
        cat.catchMouse();                // an1.catchMouse();
    }
}

向下转型：父类还原为子类型，并不是本质上修改类型
目的是可以调用子类特有的方法

Animal an1 = new Cat();            
Cat cat =(Cat)an1;                
cat.shout();                
cat.catchMouse();

基础概念
1、里氏替换原则：任何基类(父类)可以出现的地方，子类一定可以出现（子类对象可以替换父类对象）
2、即父类类型的变量可以引用子类对象如：Person st = new Student();
3、extends关键字不翻译为继承，是指的正确翻译是扩展
(1)子类可以扩展出父类没有的方法
(2)子类可以覆盖重写父类现有的方法
4、子类对象可以替换父类对象的原因是子类的范围和能力要大于或等于父类
(1)子类继承了父类，拥有了父类的属性和方法，所以子类至少等于父类，父类有的子类也有
(2)子类可以扩展和重写父类的方法，所以父类没有的，子类也可以有
5、子类方法中注意区分重写和重载
6、对象在调用方法时，需要受到对象本身的类型限制，父类的引用不能调用子类的方法（除非子类重写父类的方法）

在向下转型是防止出现类型错误
instanceof关键字：用于判断一个对象是否为某个类（或接口）的实例或者子类实例

Animal an1 = new Dog();
if(an1 instanceof cat){
    Cat cat =(Cat)an1;
    cat.shout();
    cat.catchMouse();
}
else{
    System.out.println("该类型的对象不是Cat类型");
}

8、内部类：

成员内部类：一个类中除了定义成员变量、成员方法，还可以定义类，这样的类被称为成员内部类
局部内部类：定义在某个局部范围中的类
静态内部类：用static关键字修饰的成员内部类，与成员内部类相比，静态内部类只能访问外部类的静态成员
匿名外部类：没有名称的内部类

9、异常

运行期异常

异常类名称	异常类说明
Arithmetic	算数异常
IndexOutOfBoundsException	角标越界异常
ClassCastException	类型转化异常
NullPointerException	空指针异常
NumberFormatException	数字格式化异常

···try…..catch和finally
伴随try……catch的三个常用的方法：
e.getCause():获取异常原因，获取Cause
e.toString(): 获取异常种类和错误信息
e.getMessage(): 获取错误信息

try{
    //可能发生异常的语句
}catch(Exception类或子类e){
    //对捕获的异常进行相应处理
}

finally关键字：无论异常是否发生，finally语句最终都会执行

public class yiChang{
    public static int divide(int x, int y){
        try{
            int result = x/y;
            return result;
        }catch(Exception e){
            System.out.println("捕获的异常信息为："+e.getMessage());
        }finally{
            System.out.println("执行finally代码块,无论程序是否发生异常，都会执行");
        }
        return -1;
    }
    public static void main(String[] args){
        int result = divide(4,0);
        if(result == -1){
            System.out.println("程序发生错误");
        }
        else{
            System.out.println(result);
        }
    }
}

thorws关键字：该关键词用在会抛出异常的方法名称后（方法声明后），同时支持一次性抛出多种类型的异常

[修饰符] 返回值类型 方法名 {[参数类型 参数名1]} throws 异常类1,异常类2,....{
    //方法体
}

public class paochuE{
    public static int divice(int x,int y) throws Exception{
            int result = x/y;
            return result;
        }
    public static void main(String[] args){
        try{
                int result = divice(4,0);
                System.out.println(result);
            }catch(Exception e){
                System.out.println("捕获的异常信息为："+e.getMessage());
            }
    }
}

throw关键字：用于方法体内，用于抛出一个异常类对象

[修饰符] 返回值类型 方法名{[参数列表 参数名，]} throws 抛出的异常类{
    //方法体
    throw new Exception 类或者子类构造方法;
}

public class paochuEE{
    public static void printAge(int age)throws Exception{
        if(age <= 0){
            throw new Exception("输入的年龄有误，必须输入正整数!");
        }
        else{
            System.out.println("此人年龄为："+age );
        }
    }
    public static void main(String[] args){
        int age = -1;
        try{
            printAge(age);
        }catch(Exception e){
            System.out.println("捕获的异常信息为："+e.getMessage());
        }
    }
}

自定义异常：所有的自定义类都源于Exception

class DivideByMinusException extends Exception{
    public DivideByMinusException(){
        super();
    }
    public DivideByMinusException(String message){
        super(message);
    }
}
public class zidingyiE{
    public static int divide(int x,int y) throws DivideByMinusException{
        if(y == 0){
            throw new DivideByMinusException("除数为0");
        }
        int result = x/y;
        return result;
    }
    public static void main(String[] args){
        try{
            int result = divide(4,0);
            System.out.println(result);
        }catch(DivideByMinusException e){
            System.out.println("捕获的异常信息为："+e.getMessage());
        }
    }
}

throw关键字是在方法体中抛出异常，但异常并没有解决，throws同样的是将抛向上一级，而并没有捕获异常，最终捕获异常需要使用try捕获异常，然后catch后的语句将try捕捉的异常处理。

子类对象与父类容器的关系：子类对象可以放在存放父类对象的容器里
函数调用的绑定：
静态绑定：根据变量声明的类型来决定
动态绑定：根据变量的动态类型来决定
在成员函数中调用其他的成员函数也是通过this这个对象变量来调用的

容器
·ArrayList<>

private ArrayList<String> notes = new ArrayList<String>();
//用于存放字符串类型的容器ArranList======>>又称之为泛型类
//容器类用于存放对象        ArrayList为容器的类型   <String>为元素的类型

·set

//实例化过程换
//堆区栈区方法区