本文主要是介绍java基础知识，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

强制转换

由高转低需要强制转化，低到高自动转换byte short chat int long float double

int i=128;
byte b=(byte)i;

1、不能把布尔类型转换2、不能把对象转换成不相干的类型3、转换的时候可能会出现内存溢出精度问题

int money=10_0000_0000;
int year=20;
int total=money*year;//结果溢出了int的范围
long total1=monry*((long)year);//先把一个数转化为long类型

变量

public class Demo{
    //实例变量不自行初始化默认为0或者0.0   布尔值默认为false  除了基本类型其他都为null
    String name;//实例变量，从属于对象
    
    static double a=1200;//类变量，前边加个static
    
    //main方法
    public static void main(String[] args){
        int i=10;//局部变量，其他方法中不能使用，只在该{}有用
        
        //变量类型  变量名字
        Demo demo1=new Demo();
        System.out.println(demo1.name);//输出实例变量
        
        System.out.println(a);//使用类变量
    }
    //其他方法
    public void add(){
        
    }
}

常量

static final float PI=3.14 //使用final定义常量，固定值，之后可以直接引用

运算符

int a=3;                   int a=3; 
int b=a++;    //相当于      int b=a;
                           int a=a+1;
​
int a=1;                   int a=1;
int b=++a;     //相当于     int a=a+1;
                           int b=a;

连接符

int a=1;
int b=2;
System.out.println(""+a+b)//结果为12
System.out.println(a+b+"")//结果为3

三元运算符

x ? y : z 如果x为真则返回y，如果为假，则返回z

文档注释

//使用/**加回车进行文档注释
/**
 * @author tao   作者名
 * @version 1.0  版本号
 * @since 1.8    指明需要最早使用的jdk版本
 */
public class Doc {
    String name;
​
    /**
     * 
     * @param name 参数名
     * @return     返回值情况
     * @throws Exception     抛出异常
     */
    public  String test(String name) throws Exception{
        return  name;
    }
}

用户交互Scanner

通过Scanner类来获取用户的输入

语法：Scanner s=new Scanner (System.in);

next():

1、一定要读取到有效字符后才结束输入

2、对输入有效字符之前遇到的空白，next方法会自动将其去掉

3、只有输入有效字符后才将其后面输入的空白作为分隔符或结束符

4、next（）不能得到带有空格的字符串

nextLine()：

1、以Enter为结束符，可以获得空白

switch

每个case语句中都需要一个break,不然就会输出下面全部的case值

支持使用字符串对比

print和println的区别

print输出不会换行 println输出会换行

break和continue

break用于强行跳出循环，不执行循环语句剩余的语句

continue用户终止某次循环，跳过本次循环继续执行下一次循环的判断

方法

1、方法包含一个方法头和一个方法体

修饰符 返回值类型 方法名（参数类型 参数名）{

方法体

return 返回值；

}

形式参数：用于来定义方法内的参数

实际参数：实际调用给它的参数

方法的重载

1、名字一摸一样但是参数不同(可以个数不同、类型不同、参数排列顺序不同)

2、方法的返回类型可以相同也可以不同

3、只有返回类型不同不是方法的重载

可变参数

在方法声明中在指定参数类型后加一个省略号

一个方法中只能指定一个可变参数，必须是方法的最后一个参数，任何普通的参数必须在它之前声明

递归

边界条件 前阶段 返回阶段n*n-1

数组

必须声明数组变量

int[] num;

使用new操作符来创建数组

int[] num=new int[10];

获取数组长度

num.length

数组的四个特点：

①、其长度是确定的。数组一旦被创建，它的大小就是不可以改变的

②、元素必须是相同的类型，不允许出现混合类型

③、数组中的元素可以是任何数据类型，包括基本类型和引用类型

④、数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组本身就是对象，java中对象是在堆中的，因此无论保存原始类型还是其他对象类型。数组本身是在堆中的。(new出来的都是在堆)

数组的边界

下标的合法区间：[0，length-1]

ArrayIndexOutOfBoundsException：数组下标越界异常

##

 

增强的数组循环

int[] arrays={1,2,3,4}
//适合打印输出,没有下标
for(int array:arrays){
    System.out.printl(array);
}

 

java内存分析

java内存分为堆、栈、和方法区

①、堆：存放new的对象和数组；可以被所有的线程共享，不会存放别的对象引用

②、栈：存放基本变量类型（包含这个基本类型的具体数值）；引用对象的变量（会存放这个在堆里面的具体地址）

③、方法区：可以被所有线程共享；包含了所有的calss和static变量

Arrays类

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用

具有以下功能：

1、给数组赋值：使用.fill方法

2、对数组排序：通过sort方法，升序排序

3、比较数组：通过equals方法比较数组中元素是否相等

4、查找数组元素：通过binarySearch方法对排序号的数组进行二分查找

冒泡排序

比较数组中两个相邻的元素如果第一个比第二个数大，交换他们的位置，每次比较都会产生一个最大一个最小，下一轮则少一次排序

每一轮都能产生一个最大或者最小的数放在最后面或者最前面，然后继续从第一个开始比较

面向对象OOP

思想：分类得思维，思考问题首先会解决问题需要那些分类，然后对这些分类进行单独思考。

使用new关键字创建得时候，除了分配内存空间外，还会给创建好得对象进行默认得初始化以及对类中构造器得调用

本质：以类得方式组织代码，以对象得方式封装数据

三大特性

封装：

程序设计要求”高内聚，低耦合“内聚指类的内部数据操作细节自己完成，不允许外部干涉，耦合是指暴露少量方法给外部使用

（数据的隐藏）禁止直接访问一个对象中数据的实际标识，而应该通过操作接口来访问属性私有(private)，get/set

1、提高程序的安全性，保护数据

2、隐藏代码的实现细节

3、统一接口

4、系统可维护性增加

继承：

本质是对类的抽象，extend意思为子类是父类的扩展，在JAVA中只有单继承没有多继承（一个爸爸可有多个儿子）

继承是类和类之间的一种关系。继承关系的两个类一个为子类一个为父类，子类使用extend标识继承父类

所有的类都默认继承object类

多态：

同一方法可以根据发送对象不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

存在条件：①、有继承关系

②、子类重写父类方法

③、父类引用指向子类对象

注意事项： 1、多态是方法的多态，属性没有多态

2、父类和子类有联系（存在父子关系）不可以将一个类型转化为另一个类型（ClassCastException）

3、存在条件：继承关系，方法需要重写，父类引用指向子类对象Father f1=new Son()

不能重写(无多态) ①、static方法属于类不属于实例，不能被重写

②、final常量不能被重写

③、private方法不能被重写

对象，是具体得事物，类，是抽象得，是对对象得抽象

构造方法

类中的构造器（构造方法）实在进行创建对象时候必须要调用得

①、构造方法和类的名字相同

②、必须没有返回类型也不能写void

作用：

①、new本质在调用构造方法

②、初始化对象的值

注意点：

使用new本质是在调用构造方法，定义有参一定要显示无参构造，super调用父类的构造方法必须在子类构造方法第一行

alt+insert自动将有参无参构造方法补齐

super和this

super注意点

①、super调用父类的构造方法，必须在构造方法的第一个

②、super必须只能出现在子类的方法或者构造方法中

③、super和this不能同时调用构造方法（因为都必须保证他们在第一行）

与this对比

①、代表的对象不同

this:本身调用者这个对象

super:代表父类对象

②、前提：

this:没有继承也可以使用

super：只能在继承条件才可以使用

③、构造方法

this():该类的构造

super():父类的构造

方法的重写

需要有继承关系

子类重写父类的方法，方法一致但是方法体不同

①、方法名必须相同

②、参数列表必须相同

③、修饰符：范围可以扩大，父类private子类可以编程public(反过来不行)

④、抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException(小)-->Exception(大)

为什么需要重写：父类的功能，子类不一定需要或者不一定满足

instanceof

根据父子类关系判断是否属于父子

先判断是否是继承关系，不是的话直接报错，是的话继续判断是否为父子

类的大小顺序：

Object>String

Object>Person>teacher

Object>Person>student

类型强制转化

 

//例如父类Person要使用Student子类独有的方法go()
高 -------------->低
Person person=new Student();
//这里不能使用person.go();因为go为子类独有的方法
//类型强制转化
((Student) person).go();


//子类转化为父类,可能丢失自己的本来的一些方法（大空间赋值给小空间，子类大空间中独有的方法会丢失）
Student student=new Student();
student.go();
低------------->高
Person person=student;//父类的引用指向子类的对象

①、父类的引用指向子类的对象

②、子类转换为父类（向上转型），不用强制转化，丢失子类独有方法

③、父类转化为子类（向下转型），需要强制转化

④、方便方法的调用，较少重复的代码

static

静态属性可以直接使用类名调用,静态就是属于该类，随着类加载就存在，static方法只执行一次，后面不执行

Public class Student{
    private static int age;
    private String name;
    public void run(){
        //非静态可以直接调用静态，静态不能直接调用非静态
        go();
    }
    public static void go(){
        
    }
   public static void main(String[] args){
        Student s1=new Student();
        System.out.println(Student.age);
        System.out.println(s1.age);
        s1.run();
        Student.go;//或者直接go();因为再类里面
    }
}

public class Person{
    static{
        System.out.println("静态代码")
    }
    {
        System.out.println("匿名代码")
    }
    public Person(){
        System.out.println("构造方法")
    }
    public static void main(String[] args){
        Person s1=new Person();//输出顺序：①、静态代码②、匿名代码③、构造方法
        Person s2=new Person();//只输出：②、匿名代码③、构造方法
    }
}

抽象类

子类必须重写这个父类抽象类的所有抽象方法，不然会报错，抽象类的所有抽象方法都必须由继承它的子类实现，除非子类也是抽象类 则由子子类实现。（抽象类相当于房子的图纸，设计好了让子类去实现）

注意点：

①、不能new这个抽象类，只能靠子类去实现它，只能去new他的一些子类对象

②、抽象类中可以有普通方法，抽象方法必须在抽象类中：约束作用

接口interface

接口就是规范，定义的是一组规则，体现现实中你是车，就必须能跑类似的规则

接口的本质是契约，就像法律，制定好后必须遵守

对比

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有，使用abstract定义，利用extends继承

接口：只有规范，自己无法写方法，使用interface定义，使用implement继承

⭐注意点：

①、接口中定义的所有方法都需要被子类重写实现，定义一些方法让不同的人去实现

②、接口中的所有方法定义其实都是抽象的public abstract

③、接口里面定义的属性都是常量public static final

④、接口不能被实例化，接口中没有构造方法

⑤、implement可以实现多个接口

异常机制

异常指程序运行中出现的不期而至的各种状况：文件找不到、网络链接失败、非法参数等。

java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类

分类

①、检查性异常：最具代表性的检查性异常是用户错误或问题引起的异常，程序员无法预见的

②、运行时异常：运行时异常时可能被程序员避免的异常。以检查性异常相反，运行时异常可以在编译时被忽略

③、错误ERROR：错误不是异常，而是脱离程序员控制的问题，错误在代码中通常被忽略

ERROR

ERROR类对象由java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。

java虚拟机运行错误，当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。异常发生时JVM一般会选择线程终止

还有发生再虚拟机试图执行应用时，如：类定义错误、链接错误。这些错误时不可查的，因为他们再应用程序控制和处理能力之外不允许出现的错误。

Exception

Exception中有一个重要子类RuntimeException（运行时异常）

ArrayIndexOutOfBoundsException（数组下标越界）

NullPointerException（空指针异常）

ArithmeticException（算术异常）

MissingResourceException（丢失资源）

ClassNotFoundException（找不到类）

异常处理机制

抛出异常 捕获异常

异常处理关键字：try catch finally throw throws

自定义异常

使用Java内置的异常类可以描述再编程时出现的大部分异常情况，用户可以自定义异常，只需要继承Exception类即可

步骤：①、创建自定义异常类

②、再方法中通过throw关键字抛出异常

③、如果在当前抛出异常的方法中处理异常，可使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛 出给方法调用者的异常。

④、在出现异常方法的调用者中捕获并处理异常

这篇关于java基础知识的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！