大家好，我是讯享网，很高兴认识大家。



目录：

基本数据类型

内置数据类型

引用数据类型

java基础笔记范式

类型转换

自动类型转换

强制类型转换

隐含强制类型转换

变量类型

局部变量 

实例变量/成员变量

静态变量/类变量

参数变量

修饰符

访问修饰符

非访问修饰符

运算符 instanceof

For-Each 循环/增强 for 循环 

数组

声明：

创建：使用 new 操作符 （给声明的数组分配空间）

继承

extends

implements

其他关键字

多态性

重写

重载

多态存在的三个必要条件：继承、重写、父类引用指向子类对象

多态的实现方式：重写/接口/抽象类和抽象方法

抽象类

定义：abstract class

抽象方法

封装

接口

特性

接口与类的区别

实现

标记接口

枚举

定义

使用

相关方法：values(), ordinal(), valueOf()

枚举类成员

包

泛型

泛型方法

泛型类

类型通配符

---

关于环境

JDK：用于开发和运行Java程序，包含

JRE（Java Runtime Environmet）：运行Java程序的程序

注：JVM会自动进行垃圾收集，可减少内存泄漏

环境配置：

配置环境变量

加入系统变量

在path中添加

        以找到编译器和jre

Java中，通常的做法是创建一个类，然后在类中定义变量、方法以及可能包括的主函数（在java中是程序的执行入口，必须在类中定义）。为了能运行java程序，必须包含 main 方法并且创建一个实例对象（可选，需要调用非静态方法或访问非静态字段时则必须创建一个类的实例）。

public class HelloWorld { public static void main(String[] args) //命令行参数，若要使用需要设置其值 { System.out.println("Hello World！"); //out是在System类中预定义的静态对象 } }

讯享网

class A = new class();   //Java中，使用关键字 new 来创建一个新的对象

函数格式：

import：提供一个合理的路径，使得编译器可以找到某个类（载入）

基本数据类型

内置数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型：byte、short、int、long / float、double / char / boolean

字符串

相同字符串存储在同一空间

引用数据类型

• Java中，引用类型的变量类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，一旦声明后，类型就不能被改变了。
• 对象、数组都是引用数据类型。
• 所有引用类型的默认值都是null。
• 一个引用变量可以用来引用任何与之兼容的类型。

类型转换

自动类型转换

运算中，不同类型的数据先转化为同一类型，然后进行运算，转换从低级到高级（小范围可隐式转换为大范围）。

注：int字面值可以赋值给byte/short数据类型（溢出部分从左侧开始计）

强制类型转换

格式：(type)value type  【转换的数据类型必须兼容】

隐含强制类型转换

• 整数的默认类型是 int
• 小数默认是 double 类型浮点型，在定义 float 类型时必须在数字后面跟上 F 或 f

变量类型

局部变量 

在方法、构造函数或块内部声明的变量，在声明的方法、构造函数或块执行结束后被销毁。

声明时需初始化。

实例变量/成员变量

在类中声明，但在方法、构造函数或块之外，可以声明在使用前或者使用后，属于类的实例（在对象创建的时候创建，在对象被销毁的时候销毁），每个类的实例都有自己的副本。

可被访问修饰符修饰。

如果不明确初始化，实例变量会被赋予默认值。

静态变量/类变量

在类中用static关键字声明的变量，属于类而不是实例，所有该类的实例共享同一个类变量的值。（静态变量是与类相关的变量，具有唯一性和共享性，可用于存储整个程序都需要使用的数据）

生命周期与程序的生命周期一样长。

访问修饰符可以是 public、protected、private 或者默认的访问修饰符。

在类加载时被初始化，而且只初始化一次。

与常量的区别：

常量也是与类相关的，但它是用 final 关键字修饰的变量，一旦被赋值就不能再修改。

常量在编译时就已经确定了它的值，而静态变量的值可以在运行时改变。

参数变量

方法或构造函数声明中的变量，用于接收调用该方法或构造函数时传递的值，作用域只限于方法内部。

参数变量值的传递方式：

1. 值传递：传递的是实际参数的值的副本
2. 引用传递：传递的是实际参数的引用（即内存地址），当参数变量被赋新值时会修改原始值

修饰符

访问修饰符

• default (即默认，什么也不写）: 在同一包（组织java文件的文件夹）内可见，不使用任何修饰符。

       使用对象：类、接口、变量、方法

• private : 在同一类内可见。

       使用对象：变量、方法。 注：不能修饰类（外部类）和接口

• public : 对所有类可见。

       使用对象：类、接口、变量、方法

• protected : 对同一包内的类和所有子类可见。（子类与基类不在同一包中时子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。）

       使用对象：变量、方法。 注：不能修饰类（外部类）和接口

  继承规则：

• 父类中声明为 public 的方法在子类中也必须为 public。
• 父类中声明为 protected 的方法在子类中声明为 protected 或 public，不能声明为 private。
• 父类中声明为 private 的方法，不能够被子类继承。

注：Math类的构造方法都是私有的访问权限，以此避免修改。

非访问修饰符

• static：修饰方法或变量。（静态变量与方法可直接通过类名来调用）
• final：修饰类、方法和变量，final 修饰的类不能被继承、修饰的方法不能被继承类重新定义、修饰的变量为常量故不可修改。类似于C++中的const。
• abstract：创建抽象类和抽象方法。
• synchronized、volatile：主要用于线程的编程。

运算符 instanceof

用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

如果运算符左侧变量所指的对象，是操作符右侧类或接口的一个对象，则结果为真。若被比较的对象兼容于右侧类型，该运算符仍然返回 true。

使用格式：

( Object reference variable ) instanceof  (class/interface type)

For-Each 循环/增强 for 循环 

一种主要用于数组的增强型 for 循环。（局部变量的值为数组的循环）

格式：

for(声明语句 : 表达式)

{

        //代码句子

}

e.g.

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

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

输入

Scanner类

import java.util.Scanner;

Scanner input = new Scanner(System.in);   //由InputStream对象构造 Scanner对象

double ta=input.nextDouble();   //读取用户输入的字符串

Console类

Console cons= System.console ();

String username= cons.readLine (“User name: ”);

char[] passwd= cons.readPassword (“Password: ”);   

// 为安全起见，返回的密码放在一维字符数组中，而不是字符串。处理密码后马上用一个填充值覆盖数组元素

数组

Java中的数组均为对象,所以分配空间需用关键字 new 申请堆内存。（局部变量和方法调用时的参数存储在栈内存中。）

Java中的所有对象，包括数组，都是通过引用来访问的。

声明

T[ ] array;   // 首选方法，可直观看到数据类型，作为函数的参数时也采用这种方式

或

T array[ ];   // 效果相同，但不是首选方法

创建：使用 new 操作符 （给声明的数组分配空间）

array = new T[Size];

 声明与创建：

T[ ] array = new T[Size];     //声明了数组并分配空间，但还未初始化

或

T[ ] arrayr = {value0, value1, ..., valueN};    //,初始化与声明不可分行完成

T[][] array = {{value0, value1, ..., valueN},{value0, value1, ..., valueN},{value0, value1, ..., valueN}};   //二维数组可按行输入

 数组作为函数的返回值

return array;  //返回数组名即可

一些特殊类

随机数

Math.random()：伪随机       

Math.random()产生一个[0,1)的double型随机数

i = 1+(int)( Math.random()*101)；    //[ 1,100 ] 之间的随机整数

Random类：真随机

Random i=new Random()      //Java编译器会以系统当前的时间作为随机数生成器的种子

时间

Date类：可用SimpleDateFormat类来格式化日期

java.time包：LocalDate类、LocalDateTime类

继承

继承关键字： extends 或 implements （所有类都继承于 java.lang.Object，该类在 java.lang 包中，所以不需要使用 import）

与C++继承的区别：Java中类只能单继承，但可以多重继承

extends

只能继承一个类。

implements

可变相地使 java 具有多继承的特性，使用范围为类继承接口的情况，即类可以同时继承多个接口（接口与接口间用“  ，”分隔）。

其他关键字

super ：可通过 super 关键字来实现对父类成员的访问，用来引用当前对象的父类。当需要在子类中调用父类的被重写方法时，要使用 super 关键字。

this ：指向自己的引用，引用当前对象，即它所在的方法或构造函数所属的对象实例。

final：可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。【使用 final 关键字声明类，就是把类定义为最终类，不能被继承，但其中的属性、方法不是 final 的；用于修饰方法，即该方法不能被子类重写】

注：

如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表；

如果父类的构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

多态性

多态性是对象多种表现形式的体现。（同一个事件发生在不同的对象上会产生不同的结果）

---

重写

子类定义了一个与其父类中具有相同名称、参数列表和返回类型的方法，并且子类方法的实现覆盖了父类方法的实现。

---

重载

在一个类里面，方法名字相同而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

---

重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

---

多态存在的三个必要条件：继承、重写、父类引用指向子类对象

多态的实现方式：重写/接口/抽象类和抽象方法

抽象类

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承才能被使用。

在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

定义：abstract class

抽象方法

该方法的具体实现由它的子类确定。

Abstract 关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。

---

封装

实现Java封装的步骤：

1. 修改属性的可见性来限制对属性的访问（一般限制为private）

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问（可采用 this 关键字解决同名冲突）

接口

一个抽象类型，是抽象方法的集合，通常以 interface 来声明。

访问修饰符 interface 接口名

{

        //字段

        //抽象方法

}

一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口不是类，类描述对象的属性和方法，接口则包含类要实现的方法。

接口无法被实例化，但可以被实现。

一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

接口类型可用来声明一个变量，他们可成为一个空指针，或是被绑定在一个以此接口实现的对象。

特性

• 接口是隐式抽象的，接口中的每个方法也是隐式抽象的,即会被隐式的指定为 abstract 。
• 接口中的方法都是公有的。
• 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public）。
• 接口中的方法不能在接口中实现，只能由实现接口的类来实现。

接口与类的区别

• 接口不能用于实例化对象。
• 接口没有构造方法。
• 接口中所有的方法必须是抽象方法，Java 8之后接口中可以使用 default 修饰的非抽象方法。
• 接口不能包含成员变量，除了 static 和 final 变量。
• 接口不是被类继承了，而是要被类实现。
• 接口支持多继承。

实现

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

类使用implements关键字实现接口。

访问修饰符 class 类名 implements 接口名

{

        //字段与方法

}

注：

• 类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
• 类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
• 如果实现接口的类是抽象类，那么就没必要实现该接口的方法。
• 一个类只能继承一个类，但是能实现多个接口。
• 一个接口能继承另一个接口（同样使用extends关键字），并且可以多继承（Java中的类只能单继承）。

标记接口

没有任何方法和属性的接口。仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。

用途：

1. 建立一个公共父接口
2. 向一个类添加数据类型：实现标记接口的类不需要定义任何接口方法，但能通过多态性变成一个接口类型。

枚举

一个特殊的类，一般表示一组常量。

定义

使用enum 关键字，无需加 class

使用

//声明在类外

enum Color
{
    RED, GREEN, BLUE;   //一组对象
}
public class Test
{
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}

//声明在类内

public class Test
{
    enum Color
    {
        RED, GREEN, BLUE;
    }
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}

注：

• 每个枚举都是通过 class 在内部实现的，且所有的枚举值都是 public static final
• 枚举元素可在 for 循环中迭代（类数组），也可用于 switch 语句中

enum Color
{
    RED, GREEN, BLUE;  //一组对象
}

        {

                //for循环

                for ( Color myVar : Color.values() ) 

               {
                        System.out.println(myVar);
                }

                //switch语句

                {
                      case RED:System.out.println("红色");break;
                      case GREEN:System.out.println("绿色");break;
                      case BLUE:System.out.println("蓝色");break;
                }
        }
}

相关方法：values(), ordinal(), valueOf()

enum 定义的枚举类默认继承了 java.lang.Enum 类，并实现了 java.lang.Serializable 和 java.lang.Comparable 两个接口。

values(), ordinal() 和 valueOf() 方法位于 java.lang.Enum 类中：

• values() ：返回枚举类中所有的值。
• ordinal()：找到每个枚举常量的索引，就像数组索引。
• valueOf()：根据枚举常量的名称获取对应的枚举对象。

枚举类成员

跟普通类一样可以用自己的变量、方法和构造函数，构造函数只能使用 private 作为访问修饰符，所以外部无法调用。

枚举既可以包含具体方法，也可以包含抽象方法。 如果枚举类具有抽象方法，则枚举类的每个实例都必须实现它。

包

作用：

1. 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2. 避免命名冲突。包采用了树形目录的存储方式，同一个包中的类名字不同，不同包中的类的名字可以相同，当同时调用两个不同包中相同类名的类时，应加上包名加以区别。
3. 限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

语法格式

package pkg1.pkg2.pkg3…;

//如果一个源文件开头没有使用包声明，那么其中的类、函数、枚举、注释等将被放在一个无名的包（unnamed package）中

import pkg1.pkg2.classname(.*);

//可以用 import 在源文件头部（package语句后，即包声明之前类声明之后）导入其他包中的类、接口或静态成员，若想使用的是本包中的另一个类可以省略该包名

//可以使用通配符 * 来引入包中的所有类：import com.runoob.mypackage.*;

一些 Java 中的包：

• java.lang - 打包基础的类
• java.io - 包含输入输出功能的函数

泛型

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

泛型方法

泛型方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。（类似于抽象函数）

定义规则：

• 所有泛型方法声明都有一个类型参数声明部分（由尖括号<>分隔），该类型参数声明部分在函数返回类型前。
• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
• 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像 int、double、char 等）

泛型标记符

 

泛型类

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。

和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。

一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

类型通配符