Java基础汇总

一.介绍

Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的 Java 面向对象（万物皆对象）程序设计语言和 Java 平台的总称。由 James Gosling和同事们共同研发，并在 1995 年正式推出。

后来 Sun 公司被 Oracle （甲骨文）公司收购，Java 也随之成为 Oracle 公司的产品。

Java分为三个体系：

• JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）
• JavaEE  (J2EE)     (Java 2 Platform,Enterprise Edition，java平台企业版)
• JavaME  (J2ME)    (Java 2 Platform Micro Edition，java平台微型版)。

2005 年 6 月，JavaOne 大会召开，SUN 公司公开 Java SE 6。此时，Java 的各种版本已经更名，以取消其中的数字 "2"：J2EE 更名为 Java EE，J2SE 更名为Java SE，J2ME 更名为 Java ME。

Java主要特性

1.Java语言简单：

语法与C与C++很接近，易学易懂，Java摒弃了C语言的指针和多继承，并提供了自动分配和回收内存空间，无需担忧内存。

2.Java语言是面向对象的：

Java语言提供类、接口和继承等面向对象的特征，类之间只支持单继承，接口支持多继承，同时也支持类和接口的实现机制（implements），Java全面支持动态绑定，C++语言只对虚函数使用动态绑定，Java是一个纯面向对象的程序设计

3.Java语言是分布式的：

Java 语言支持 Internet 应用的开发，在基本的 Java 应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括 URL、URLConnection、Socket、ServerSocket 等。Java 的 RMI（远程方法激活）机制也是开发分布式应用的重要手段

4.Java语言是健壮的：

强转型机制、异常处理、垃圾的自动收集是Java健壮的重要保证，Java安全检查机制更具健壮性

5.Java语言是安全的：

Java通常被用在网络环境中 ，Java 提供了一个安全机制以防恶意代码的攻击。除了Java 语言具有的许多安全特性以外 ，Java 对通过网络下载的类具有一个安全防范机制（类 ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类 SecurityManager）让 Java 应用设置安全哨兵

6.Java 语言是体系结构中立的：

Java 程序（后缀为 java 的文件）在 Java 平台上被编译为体系结构中立的字节码格式（后缀为 class 的文件），然后可以在实现这个 Java 平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发

7.Java语言是可移植的：

可移植性来源于体系结构中立性，另外，Java 还严格规定了各个基本数据类型的长度。Java 系统本身也具有很强的可移植性，Java 编译器是用 Java 实现的，Java 的运行环境是用 ANSIC 实现的

 8.Java是解释型的：

Java 程序在 Java 平台上被编译为字节码格式，然后可以在实现这个 Java 平台的任何系统中运行。在运行时，Java 平台中的 Java 解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中（一次编译，到处运行）

9.Java是最高性能的：

与那些解释型的高级脚本语言相比，Java 的确是高性能的。事实上，Java 的运行速度随着 JIT(Just-In-Time）编译器技术的发展越来越接近于 C++

10.Java语言是多线程的：

Java 语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为 synchronized）

11.Java语言是动态的：

Java 语言的设计目标之一是适应于动态变化的环境。Java 程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。另外，Java 中的类有一个运行时刻的表示，能进行运行时刻的类型检查

---

二.Java基础语法

一个Java程序可以看作一系列对象的集合，对象之间相互协作调用彼此的方法协同工作

对象：对象是类的一个实例，有属性和行为，比如一个人，他的名字、年龄、身高是他的属性，那么他吃饭、说话就是他的行为。

类：类是一个模板，描述一类对象的属性、行为。

方法：方法就是行为，一个类可以有很多方法。数据修改、逻辑运算以及所有的动作都是在方法种完成的。

实例变量：每个对象都有他的实例变量，对象的状态由实例变量的值来决定

第一个Hello world！

public class Hello_World
{
    public static void main(String[] args)
    {
        System.out.println("Hello world!");
    }
}

 public（访问修饰符）static（关键字）void（返回类型）main（方法名）String(String类) [ ] args （字符串数组）

基本语法（规范）

大小写敏感

类名首字母大写，多个单词组成，首字母都大写

方法名首字母小写，若干个单词组成后面的大写

源文件名.java:源文件名与类同名

主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行

Java修饰符

像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：

1. 访问控制修饰符 : default, public , protected, private
2. 非访问控制修饰符 : final, abstract, static, synchronized

后续会讲解..........

---

三.面向对象

Java作为一种面向对象语言。支持以下基本概念：

1. 多态
2. 继承
3. 封装
4. 抽象
5. 类
6. 对象
7. 实例
8. 方法
9. 重载 

详细的可以去看看我这篇：什么是面向对象（OOP）？_CSDNzgcxy的博客-CSDN博客

---

四.基本数据类型

变量就是申请内存来存储值，当创建变量的时候，需要在内存种申请空间。

内存管理系统根据的变量为变量分配存储空间，分配的空间只能来存储该类型数据。

通过不同类型的变量，可以在内存中存储整数、浮点数、字符串。

Java的两大数据类型：内置数据类型，引用数据类型

1.内置数据类型

数字型

1. 整数型：byte、short、int、long
2. 浮点型：float、double

字符型：char

布尔型：boolean

2、引用数据类型

引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了

1. 对象、数组都是引用数据类型。
2. 所有引用类型的默认值都是null。
3. 一个引用变量可以用来引用任何与之兼容的类型。
4. 例子：Student  student = new Student("mmd")。

3.自转与强转(重要基础)

括号里是二进制位数，这里的大小比较是范围的大小。

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算

由小到大  byte（8）、short（16）、char(16) ->int(32)->long(64)->float(32)->double(64)

看到这里肯定会有疑问，long占8个字节、float占4个字节，但是为什么long的最大数比float小

public class Hello_World
{
    public static void main(String[] args)
    {
        System.out.println("long二进制位数"+Long.SIZE);
        System.out.println("long最大范围"+Long.MAX_VALUE);
        System.out.println("long二进制位数"+Float.SIZE);
        System.out.println("float最大范围"+Float.MAX_VALUE);
        //long二进制位数64
        //long最大范围9223372036854775807
        //long二进制位数32
        //float最大范围3.4028235E38
    }
}

Long是整形，long是精确的，精确到 个位 的。
而Float是浮点型，它是有有效位数的，从上面的结果可以看出，3.4028235才是Float的精确位数浮点型来说，有一部分是用来表示有效位数的，有一部分是用来表示多少次方

        float i=133312312F;
        long x= 2111111111212L;
        i=x; //float 转long自转
        x= (long) i;//long 转float强转

小转大自转，大转小强转。小和大代表小范围、大范围

数据类型转换必须满足如下规则：

• 1. 不能对boolean类型进行类型转换。

• 2. 不能把对象类型转换成不相关类的对象。

• 3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

• 4. 转换过程中可能导致溢出或损失精度

---

五.Java变量类型

在Java语言中，所有变量使用前必须先声明

type（数据类型） identifier（变量名） =  value（值） 可以同时声明多个变量  

int a=1 , b=2 , c=3;

Java支持的变量类型

1. 类变量：独立于方法外的变量，用static修饰
2. 实例变量：独立于方法外的变量，不需要static修饰
3. 局部变量：类的方法中的变量

    String name="Ninja"; //实例变量
    static int a=1; //类变量

    public void cat()
    {
        int a=1; //局部变量
    }

1. 类变量（静态变量）

1.类变量又叫静态变量，用static关键字修饰，但必须在方法外

2.无论一个类创建了多少个对象，类只拥有类变量的一份拷贝

3.类变量除了被声明成常量外很少使用，类变量初始化后不能改变

4.类变量存储在静态存储区，经常被声明为常量，很少单独使用static声明变量

5.类变量在第一次访问时创建，在程序结束时销毁 （有点像生活中那种一次性的东西）

6.与实例变量具有相似的可见型。但为了对类的使用者可见，通常使用public修饰

7.默认值最初值，可以在声明的时候指定，也可以在构造方法中指定，静态代码块初始化

8.类变量可以通过ClassName.VariableName的方式访问

9.类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母
 

public class Hello_World
{
    public static double money;
    public final static String NAME="程序猿";
    public static void main(String[] args)
    {
        money=100000;
        System.out.println(NAME+" 年薪: "+money+" +");
    }
}

2.实例变量

实例变量声明在类中，但在方法、构造方法、语句块之外

当一个对象被实例化后，每个实例变量的值就跟着确定

实例对象在对象创建的时间创建，在对象被销毁的时候销毁。（情同手足，共进退）

实例变量至少被一个方法、构造方法或者语句块引用，使外部能通过这些方式获取到实例变量信息

实例变量可以声明在使用前或者声明在使用后

访问修饰符可以修饰实例变量

实例变量对类中的方法、构造方法、语句块是可见的，可以使用访问修饰符让子类可见

实例变量的值可以声明时指定，也可以在构造方法中指定

实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName

public class Hello_World
{
    public String name;
    private double money;

    public Hello_World(String name) {
        this.name = name;
    }
    public void setMoney(double money) {
        this.money = money;
    }
    public void print()
    {
        System.out.println("NAME："+name);
        System.out.println("薪水："+money);
    }
    public static void main(String[] args) {
        Hello_World world=new Hello_World("Ninja");
        world.setMoney(1500);
        world.print();
    }
}

3.局部变量

局部变量声明在构造方法、方法、语句块中

局部变量在方法、构造方法、语句块执行的时候被创建，执行完销毁

访问修饰符不能修饰局部变量

局部变量只在声明他的地方可见

局部变量是在栈上分配的

局部变量没有默认值，必须初始化，才能使用

public class Hello_World
{
    public void pushage() //方法
    {
        int age=2; //局部变量
        System.out.println("dog的年龄 ："+age);
    }
    public static void main(String[] args) {  //主方法
        Hello_World world=new Hello_World();
        world.pushage();
    }
}

六.Java修饰符

Java修饰符分别为：访问修饰符、非访问修饰符。

修饰符用来定义类、方法、变量。通常放到语句最前端。

1.访问控制修饰符

我们使用下面这些权限修饰符，在类的内部设置了边界，保护类、变量、方法、构造方法。不同程度的“锁”，决定能被谁使用

作用域	当前类	同包	子类	其他
private	支持	不支持	不支持	不支持
default	支持	支持	不支持	不支持
protected	支持	支持	支持	不支持
public	支持	支持	支持	支持

1.default（默认）：在同一包内可见，不使用任何修饰符，可以使用在：类、接口、变量、方法 

2.private （私有的）：在同一类可见，可以使用在：变量、方法。不能修饰类（外部类）

3.public     (公共的)  ：对所有类可见 ，可以使用在：类、接口、变量、方法

4.protected（受保护的）：同一包的类以及所有子类可见，可以使用在：变量、方法 。不能修饰类（外部类）

1.default默认访问修饰符

使用default修饰的方法和变量，对一个包里的类是可见的。接口都隐式的声明为public static final，而接口里面的方法默认访问权限是：public

2.private私有访问修饰符

private是最严格的访问级别，所以被声明private的方法、变量、构造方法只能被所属类访问。类和接口不能声明为private，声明private的变量只能通过类中公共的getter方法被外部访问

主要用来隐藏类的实现细节和保护类的数据

3.public公共访问修饰符

被声明public的方法、变量、构造方法、接口可以被任何的类访问。

如果几个相互访问public类分布在不同的包里，则需要导入public类所在的包，由于类的继承性，类的公共方法和变量都能被其子类继承

4.protected受保护访问修饰符

子类和基类在同一包里：被声明protected的变量、方法、构造方法能被同包的所有类访问

子类和父类不在同一包里：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法

包内可见，子类可见。不能修饰类（内部类除外）

2.非访问修饰符

为了实现一些其他的功能，Java也提供了许多非访问修饰符：

static 修饰符：用来修饰类方法和类变量

final 修饰符：用来修饰方法、变量、类。final修饰的类不能被继承，修饰的方法不能被重写，修饰的变量为常量，不能被修改。

abstract 修饰符：用来创建抽象类和抽象方法 

synchronized和volatile修饰符：主要用于线程的编程

1.static修饰符

静态变量：static关键字用来声明独立于对象的静态变量，无论实例化多少个对象，它的静态只有一份拷贝，静态变量也叫类变量，static不能修饰局部变量。

静态方法：static关键字用来声明独立于对象的静态方法，静态方法不能使用非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

为什么说静态变量无论实例多少对象，只有一份拷贝

因为在程序运行时只会加载一次类，加载类的时候由于静态的内容是存储在类的空间中的，他是属于类的，所以你在创建对象的时候并不会对静态的内容造成什么影响，因为你对象只能拷贝类中非静态的成员，所以静态变量只能初始化一次且只有一份

public class Hello_World
{
    public static int statics=0;
    public int nostatic=0;
    public Hello_World()
    {
        statics++;
        nostatic++;
        System.out.println("静态变量 ："+statics+"-------"+"实例变量 ："+nostatic);
    }
    public static void main(String[] args) {
        for (int i = 0; i <10 ; i++) {
            Hello_World world=new Hello_World();
        }
    }
}

 实例：

public class Hello_World
{
    public static int num=0;
    public static int count(){
        return num;
    }
    public static int add(){
        return num++;
    }
    public static void main(String[] args) {
        System.out.println("初始值"+num);
        for (int i = 0; i <1000 ; i++)
        {
            add();
        }
        System.out.println("循环结果 ："+Hello_World.count());
    }
}

 2.final修饰符

1.final表示’最后‘最终的意思，变量一旦赋值不能重新被赋值，被final修饰的变量必须显式指定初始值才能使用

2.final修饰的方法不能被重写，就是防止该方法内容被修改

3.final修饰的类不能被继承，任何类都无法继承它的特性

final 修饰符通常和 static 修饰符一起使用来创建类常量

3.abstract修饰符

抽象类不能实例对象，声明抽象类的目的就是为了将来对该类进行扩充

一个类不能同时被final和abstract修饰，如果一个类有抽象方法就必须声明成抽象类

抽象类可以包含抽象方法和非抽象方法

1.抽象方法没有任何的实现，该方法的实现细节由子类提供

2.抽象方法不能声明为static和final

3.抽象类的子类必须实现父类的所有抽象方法，除非子类也是抽象类

4.如果一个类包含多个抽象方法，那么该类必须声明为抽象类，抽象类里可以不是抽象方法

4.synchronized修饰符

声明的方法，同一时间只能被一个线程访问

5.transient修饰符

序列化的对象里包含被transient修饰的实例变量时，JVM跳过该特定的变量

该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型

6.volatile修饰符

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

一个 volatile 对象引用可能是 null。

volatile只能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的。

volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞

七.流程控制语句

---

本文部分转载菜鸟教程加上个人理解  感谢支持 后续持续更新