001 JAVA基础

JAVA环境搭建

下载JDK并添加环境变量

1. 添加环境变量JAVA_HOME(JDK的安装目录)

C:\Program Files\Java\jdk1.8.0_66

2. 添加环境变量 JRE_HOME(JRE的安装目录)

C:\Program Files\Java\jre1.8.0_66

3. 添加环境变量CLASSPATH(JAVA类库的目录)

.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar 

4. 在Path环境变量添加JAVA和JRE的bin目录

%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin

5. 验证环境变量

检验是否配置成功 运行cmd 输入 java -version （java 和 -version 之间有空格）

C:\Users\87321>java -version
java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b17)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b17, mixed mode)

如上所示，说明安装和配置成功

JAVA基础语法

数据类型

JAVA数据类型

基本数据类型和引用数据类型的区别在于，基本数据类型的值直接保存在栈中，而引用数据类型保存在堆内存

基本数据类型大小

• byte 1字节
• short 2字节
• int 4字节
• long 8字节
• float 4字节
• double 8字节
• char 2字节

基本数据类型包装类

在JAVA中，提供了这么一种方式，可以方便做数据类型转换，叫做包装类。JAVA的8个基本数据类型都有对应的包装类用于数据类型转换。

自动类型转换

在JAVA程序中，不同的基本数据类型的数据之间经常需要进行相互转换。例如

int nNum1=100;		//n为整数
double nNum2=nNum1;	//nNum1自动转换为double

代码中int型变量可以直接转换为double型变量完成赋值操作，这种转换称为自动转换。完成自动转换的条件为：

1. 目标类型能与源类型兼容，如double类型兼容int型，但是char型不能兼容int型
2. 目标类型大于源类型，如double类型长度为8字节，int类型为4字节，因此double类型的变量里可以直接存int

强制类型转换

以下代码不能完成自动类型转换

int age=20;
char sex='男';
char result=age+sex

这个时候无法完成自动类型转换，就需要使用强制类型转换。格式:(数据类型)数值

int age=20;
char sex='男';
char result=(char)age+sex

常量

所谓常量，可以理解为一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。格式：final 常量名=值

final double PI=3.14;
final int MAX=100

控制台的输入—Scanner的使用

使用Scanner分为三步

1. 导入Scanner类

import java.util.Scanner;

2. 定义一个Scanner类型的变量

Scanner input =new Scanner(System.in)

3. 获取键盘输入的数据

String bookName=input.next();	//读取字符串
int nID=input.nextInt();		//读取整形

数组

如何使用数组

1. 声明数组(注意:声明数组时，不需要设置数组长度)

int scores[];
int[] scores;

2. 分配空间

int scores[]=new int[10];

3. 赋值

scores[1]=100;	//直接赋值
int scores[]={1,2,3,4,5};				//声明并赋值
int scores[]=new int[10]{1,2,3,4,5};	//声明并赋值

注意:数组元素根据类型不同，有不同的初始值

• int默认初始值为0
• String默认初始值为null
• double默认初始值为0.0

数组的遍历

1. 使用for循环

int scores[]={1,2,3,4,5};
for (int i=0;i<scores.length;i++)
{
	System.out.print(scores[i]);
}

2. 使用foreach

int scores[]={1,2,3,4,5};
for (int score:scores)
{
	System.out.print(score);
}

JAVA面向对象

类与对象

如何定义JAVA中的类

1. 指定类的访问属性
2. 定义类名
3. 编写类的属性
4. 编写类的方法

public class Cellphone {
    //属性
    private float cpu;
    private float screen;
    private float mem;

    //方法
    public void call(){
        System.out.print("打电话");
    }
}

如何使用JAVA中的对象

1. 创建对象
2. 使用对象

Cellphone phone=new Cellphone();
phone.call();

JAVA中的构造方法

构造方法的特点

1. 使用new+构造方法 创建一个新的对象
2. 构造方法与类名一致
3. 构造方法无返回值

public class Cellphone {
    //属性
    private float cpu;
    private float screen;
    private float mem;

    //无参构造
    public Cellphone() {
    }
    
    //有参构造
    public Cellphone(float cpu, float screen, float mem) {
        this.cpu = cpu;
        this.screen = screen;
        this.mem = mem;
    }

    //方法
    public void call(){
        System.out.print("打电话");
    }
}

多态

引用多态

• 父类的引用可以指向本类的对象

Animal obj1=new Animal();

• 父类的引用可以指向子类的对象

Animal obj1=new Dog();
Animal obj1=new Cat();

方法多态

obj1.eat(); 	//调用父类的
obj2.eat(); 	//子类重写
obj3.eat(); 	//子类重写，依然调用父类的

多态中的引用类型转换

• 向上类型转换(隐式/自动类型转换)，是小类型到大类型的转换

Dog obj1=new Dog();
Animal obj2=obj1;

• 向下类型转换(强制类型转换)，是大类型到小类型的转换

Dog obj3=(Dog)obj2;

• 使用instanceof检测是否可以强制转换

Dog dog=new Dog();
Animal animal=new Animal();
if(animal instanceof Dog)
{
    Dog dog1=(Dog)animal;
}

JAVA中的接口

声明接口

类是一种具体实现体，而接口定义了某一批类所遵守的规范，接口不关心这些类的内部数据，也不关心这些类里的实现细节，他只规定这些类里必须提供某些方法。

//接口定义使用关键字inerface
[修饰符] inerface 接口名 [extends 父接口1,extends 父接口2...]
{
   //常量
   //抽象方法
}

//示例：
public interface IAction {
   void test1();       //默认接口中的方法就是公有方法 不需要实现
   void test2();
   void test3();
}

接口的存在就是弥补JAVA的单继承，JAVA的单继承主要是继承父类的数据，而一个类的行为方法一般都是使用接口进行扩展，一个类可以实现多个接口，扩展无限多的方法

使用接口

实现接口使用implements关键字，如果要继承父类，必须在实现接口之前

[修饰符] class 类名 extends 父类 implements 接口1，接口2...
{
    
}

//示例:
public class Test implements IAction{
    //实现接口 必须重新接口中的所有方法
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }

    @Override
    public void test3() {

    }
}

接口的特点：

• 接口默认就是abstract修饰
• 接口默认只能是public的
• 接口可以继承自多个父接口
• 接口中的属性是常量(public static final …)
• 接口中的方法都是抽象方法(public abstract)

JAVA异常

什么是异常

在程序执行中，任何中断正常程序流程的条件就是错误或异常。例如，程序运行发生下列情况时，会发生异常：

• 想打开的文件不存在
• 网络连接中断
• 接受了不符合逻辑的操作数
• 系统资源不足

异常的分类

• Throwable类是JAVA语言中所有错误和异常的超类
• Error RuntimeException及其子类，其他异常表示一种运行时的困难，他通常由环境效果引起，可以进行处理

Throwable类的子类

在JAVA编程语言中，错误类(Error)定义被认为是不能恢复的严重错误条件(如资源耗尽)。在大多数情况下，当遇到这样的错误时，建议让程序中断，应用程序一般不对此问题进行处理。

异常处理程序运行程序捕获异常(Exception)，处理它们，然后继续程序执行。他是分层把关，因此，错误情况不会介入到程序正常流程中。

常用异常类

异常类	原因
ArtimeticException	出现异常的运算条件时，抛出此异常
ArrayStoreException	试图将错误类型的对象存储到一个对象数组时抛出的异常
ClassCastException	当试图将对象强制转换为不是实例的子类时。抛出该异常
IndexOutOfBoundsException	指示某排序索引超出范围时抛出
NullPointException	当应用程序试图在需要对象的地方使用null时，抛出该异常

异常示例

public class Main {
    public static void main(String[] args) {

        String str=null;
        System.out.println(str.length());
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N9jPVPNV-1623031054233)(001 JAVA基础.assets/1622357744881.png)]

捕获异常

• 使用try-catch捕获异常

语法格式：

try
{
    //代码块中的代码可能抛出异常
}
catch(MyExceptionType e)
{
    //处理try代码块中抛出的MyExceptionType类型的异常实例e
}
finally
{
    //无论是否有异常抛出，此部分代码总在最后被执行
}

示例：

public class Main {
    public static void main(String[] args) {
        String str=null;
        int lenth=0;
        try {
            lenth=str.length();
            System.out.println(lenth);
        } catch (NullPointerException e) {
            System.out.println("Exception occured:"+e);
        }finally {
            System.out.println("Completed!");
        }

    }
}

运行结果：

Exception occured:java.lang.NullPointerException
Completed!

Process finished with exit code 0

• 多异常情况下的catch

当try代码块中可能会抛出1个到多个异常，如何处理这可能的多个异常？非常简单，就是按照异常的包容性(子类在前，父类在后)，把需要捕获后处理的异常对应的catch逐次排列即可

public class Main {
    public static void main(String[] args) {
     String str=null;
     int length=0;
     try {
         length=str.length();
         System.out.println(length);
     }catch (NullPointerException e){
         System.out.println("Exception occured:"+e);
     }catch (ArithmeticException e){
         System.out.println("Exception occured:"+e);
     }catch (Exception e){
         System.out.println("Exception occured:"+e);
     }
    }
}

• 捕获所有异常使用Exception

catch(Exception e)
{
    ...
}