Java知识点汇总

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

第一个程序

创建文件HelloWorld.java，注意文件名需要与类名一致。

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

String args[] 与String[] args都可以执行,推荐使用String [] args

使用javac进行编译 javac HelloWorld.java 如果有编码问题可以使用 javac -encoding UTF-8 HelloWorld.java

使用java运行 java HelloWorld

主要特性

语言简单没有操作符重载多继承自动的强制类型转换不使用指针。使用引用，提供了自动分配和回收内存空间
面向对象类、接口和继承等面向对象的特性，类为单继承，接口之间的多继承，全面支持动态绑定。
分布式支持internet应用的开发，网怒应用编程接口 java net提供了用于网络应用编程的类库
健壮强类型转换、异常处理、垃圾的自动收集等
语言安全提供了安全机制以防恶意代码的攻击
体系结构中立
可移植
解释性语言
高性能的
多线程

开发环境安装

下载jdk http://www.oracle.com/technetwork/java/javase/downloads/index.html后安装
配置环境变量
- JAVA_HOME C:\Program Files (x86)\Java\jdk1.8.0_91
- PATH %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin
- CLASSPATH %JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar
测试JDK是否安装成功使用 java -version java javac命令来测试是否正常安装

基本语法

大小写敏感
类名首字母应该大写，若由多个单次组成，每个单词的首字母应该大写
方法名应该由小写字母开头，若由若干个单词组成，后面的每个单词首字母应该大写
源文件名必须与类名相同，文件名的后缀为.java
主方法入口, 所有的java程序由public static void main (String[] args)方法开始执行

标识符
标识符都应该以字母 A-Z a-z $ _ 开始
首字符之后可以是字母A-Z a-z $ _ 或数字的任何字符组成
关键字不能用作标识符
标识符是大小写敏感的

修饰符
访问控制修饰符 default public protected private
非访问控制修饰符 final abstract static synchronized

变量
局部变量
类变量（静态变量）
成员变量（非静态变量）

数组

存储在堆上的变量，可以保存多个同类型的变量

枚举

枚举限制变量只能是预先设定好的值，枚举可以单独声明或者声明在类里面，方法、变量、构造函数也可以在枚举中定义
```
enum color {
  RED,
  GREEN,
  BLUE;
}

// 通过class在内部实现
class Color {
  public static final Color RED = new Color ();
  public static final Color BLUE = new Color ();
  public static final Color GREEN = new Color ();
}

// 通过for语句迭代枚举元素
for (Color myVar : Color.values()) {
  	System.out.println (myVar);
}

// values 返回枚举类中所有的值 Color [] arr = Color.values ();
// ordinal 可以找到每个枚举常量的索引，就像数组索引一样
// valueOf 返回指定字符串值的枚举常量 Color.valueOf ("RED")
```
关键字

保留字不能用于常量、变量、和任何标识符的名称
- 访问控制
  - private 私有的
  - protected 受保护的
  - public 公共的
  - default 默认
- 类、方法和变量修饰符
  - abstract 声明抽象
  - class 类
  - extends 扩充继承
  - final 最终的不可改变的
  - implements 实现（接口）
  - interface 接口
  - native 本地原生方法（非java实现）
  - new 新创建
  - static 静态
  - strictfp 严格，精准
  - synchronized 线程同步
  - transient 短暂
  - volatile 易失
- 程序控制语句
  - break 跳出循环
  - case 定义一个值以供switch选择
  - continue 继续
  - default 默认
  - do 运行
  - else 否则
  - for 循环
  - if 如果
  - instanceof 实例
  - return 返回
  - switch 根据值选择执行
  - while 循环
- 错误处理
  - asset 断言表达式是否为真
  - catch 捕获异常
  - finally 有没有异常都执行
  - throw 抛出一个异常对象
  - throws 声明一个异常可能被抛出
  - try 捕获异常
- 包相关
  - import 引入
  - package 包
- 基本类型
  - boolean 布尔型
  - byte 字节型
  - char 字符型
  - double 双精度浮点
  - float 单精度浮点
  - int 整形
  - long 长整形
  - short 短整形
- 变量引用
  - super 父类超类
  - this 本类
  - void 无返回值
- 保留关键字
  - goto 是关键字，但不能使用
  - const 是关键字，但不能使用
  - null 空

基本数据类型

内置数据类型八种基本类型六种数字类型 (四个整数型两个浮点型) 一种字符类型还有一种布尔型

byte 8位有符号最小值-128 最大值127 默认值0

short 16位有符号最小值-32768 最大值32767 默认值 0

int 32位有符号最小值 -2147483648 最大值 2147483647 默认值0

long 64位有符号最小值 -2^63 最大值 2^63-1 默认值 0L

float 32位默认值0.0f, 不能用来表示精确的值，如货币

double 64位默认值0.0d 不能用来表示精确的值, 如货币

boolean 1位两个取值 true 和 false 默认值为false

char 16位最小值\u0000 最大值 \uffff char 数据类型可以存储任何字符

变量类型

所有的变量在使用前必须声明，声明变量的基本格式 type identifier = [value], identifier = [value];

type为java的数据类型 identifier是变量名可以使用逗号隔开来声明多个同类型变量

int a, b, c;
int d = 3, e = 4, f = 5;
String s = "hello world";

//定义二进制数
int binary = 0b00111100;

Java语言支持的变量类型有

类变量独立与方法之外的变量用static修饰有默认值通过ClassName.VariableName进行访问

实例变量独立于方法之外的变量没有static修饰有默认值，变量的值可以在声明时指定，也可以在构造方法中指定通过ObjectReference.VariableName进行访问

局部变量类的方法中的变量没有默认值，需要初始化

修饰符

访问修饰符定义类、方法、或者变量，通常放在语句的最前端
- default 什么也不写
- private
- public
- protected
非访问修饰符
- static 修饰类和类变量局部变量不能声明为static
- final 修饰类、方法和变量修饰的类不能被继承方法不能被继承类重新定义修饰的变量为常量
- abstract 用来创建抽象类和抽象方法抽象类不能用来实例化对象，声明抽象类的唯一目的就是未了将来对该类进行扩充一个类不能同时被abstract 和 final修饰
  - 抽象方法是一种没有任何实现的方法，该方法需要具体实现由子类提供
  - 抽象方法不能被声明为final 和 static
  - 任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类
  - 一个类包含若干个抽象方法，该类必须声明为抽象类，抽象类可以不包含抽象方法
  - 抽象方法的声明以分号结尾 public abstract sample ();
- synchronized 和 volatile 主要用来线程的编程
  - synchronized关键字声明的方法同一时间只能被一个线程访问
  - volatile 修饰的成员变量在每次被线程访问时，都强制从贡献内存中重新读取该成员变量的值，而且，当成员变量发生变化时，会强制线程将变化值写回到贡献内存。
  运算符
算术运算符 + - * / %(取余) ++ 自增 – 自减
关系运算符 == != > < >= <=
位运算符位运算符作用在所有的位上，并且按位运算
- & 对应位全为1 结果为1 否则为0
- | 对应位都是0 结果为0 否则为1
- ^ 对应位值相同结果为0 否则为1
- ~ 按位取反 0变为1 1变为0
- << 按位左移运算符左操作数按位左移右操作数的位数
- >> 按位由移运算符左操作数右移右操作数的指定的位数
- >>> 按位右移补零操作符
逻辑运算符
- && 两个操作数都为真，条件才为真
- || 任何两个操作数任何一个为真，条件为真
- ! 反转操作数的逻辑状态
赋值运算符
- = | += | -= | *= | /= | %= | <<= | >>= | &= | ^= | |=
其他

？：三元运算符 3个操作数需要判断布尔表达式的值 var x = expression ? value : value2;

instanceof 用于操作对象实例检查该对象是否是一个特定的类型

(Object reference variable) instanceof (class / interface type)
```
String name = "James"
boolean result = name instanceof String;
```
运算符优先级
- 后缀 > 一元 > 乘性 > 加性 > 移位 > 关系 > 相等 > 按位与 > 按位异或 > 按位或 > 逻辑与 > 逻辑或 > 条件 > 赋值 > 逗号
- 一元>二元>三元
- 算术>关系>位运算符>逻辑>赋值

循环

do … while 循环循环体至少执行一次
while循环满足条件才执行循环体
for循环
- java5以后有增强for循环
- for循环执行次数在执行前就确定
- 最先执行初始化步骤，可以声明一种类型，可初始化一个或多个变量，也可以是空语句
- 检查布尔表达式的值如果为true，循环体执行，如果为false，循环终止
- 执行一次循环后，更新循环控制变量
- 再次检测布尔表达式的值，循环执行上面的过程

增强for循环用于数组的增强for循环 for (声明语句 : 表达式) {}

int [] numbers = {10, 20, 0, 200, 2001, 20}
for (int x : numbers) {
  	System.out.println ("x == " + x);
}

String [] names = {"james", "lucas", "jobs", "jim", "teddy"}
for (String x : names) {
  System.out.println ("x == " + x);
}

break关键字
- 主要用来在循环语句中或者switch语句中，用来跳出整个语句
- 跳出最里层的循环，并且继续执行该循环下面的语句
continue关键字
- 适用于任何循环结构，让程序立刻跳转到下一次循环的迭代
- for循环中，continue语言使程序立刻跳转到更新语句
- while或者do…while循环中，程序立即跳转到布尔表达式的判断语句

条件语句

if … else
- if (布尔表达式) {//布尔表达式为true将执行的语句}
- if (布尔表达式) {} else {}
- if (布尔表达式) {} else if {} else if {} else {}
嵌套的if … else 语句 if (布尔表达式) { if (布尔表达式) {}}
switch case 语句
- 语句判断一个变量与一系列值中的某个值是否相等，每个值称为一个分支
- switch语句中的变量类型可以是 byte short int char JDK7开始支持String类型 case标签必须为字符串常量或字面量
- 可以有多个case语句，每个case后面跟一个要比较的值和冒号
- case语句中的值的数据类型必须与变量的数据类型相同
- 变量的值与case语句的值相等时，case语句之后的语句开始执行，直到break语句出现才会跳出switch语句
- switch语句如果没有case语句，程序会执行下一条case语句，直到出现break语句。
- switch语句可以包含一个default分支，default分支在没有case语句的值和变量的值相等的时候执行。

数组

首先必须声明数组变量才能在程序中使用数组。dataType [] arrayRefVar 或 dateType arrayRefVar[];

创建数组

arrayRefVar = new dataType[arraySize];
声明与创建可以用一条语句来完成 dataType[] arrayRefVar = new dataType[arraySize];
还可以在创建过程中赋值 dataType[] arrayRefVar = {value0, value1, … , valuek};

处理数组

通常使用基本循环或者For-Each循环

int total = 0
for (int i = 0; i < myList.length; i++) {
	total += myList[i];
}

//For-Each循环
for (type element : array) {
  System.out.println (element)
}

数组可以作为函数的参数

void printArray(int [] array) {
  	for (int i = 0; i < array.length; i++){
      System.out.println (array[i])
    }
}

数组可以作为函数的返回值

int [] reverse (int [] list){
  int [] result = new int [list.length];
  for (int i = 0, j  result.lenght - 1; i < list.lenght; i++, j--) {
    result[j] = list[i];
  }
  return reult;
}

多维数组

多维数组可以看成是数组的数组二维数组就是一个特殊的一维数组，每一个元素都是一个一维数组

type [] [] typeName = new type[typeLength1][typeLength2];

类

继承

通过extends关键字声明一个类冲另外一个类继承而来 class A {} class B extends A {}

// 父类
public class Animal {
  private String name;
  private int id;
  // 构造函数
  public Animal (String name, int id) {
    this.name = name;
    this.id = id;
  }
  // 吃
  public void eat () {}
  // 睡
  public void sleep () {}
  // 介绍
  public void introduction () {}
}

//继承
public class Penguin extends Animal {
  public Penguin (String name, int id) {
    super (name, id);
  }
}

继承类型 java不支持多继承单支持多重继承
继承的特性
1. 子类拥有父类非private的属性和方法
2. 子类可以拥有自己的属性和方法子类可以对父类进行扩展
3. 子类可以用自己的方式实现父类的方法
4. 继承是单继承，可以进行多重继承。

继承关键字

extends 只能继承一个类

implements 可以同时继承多个接口，多个接口之间可以用,分割

public interface A {
  public void eat ();
  public void sleep ();
}
public interface B {
  public void show ();
}

public class C implements A, B {
}

super和this关键字 super关键字来实现对父类成员的访问， this关键字指向自己的引用
final关键字声明的类可以把类定义为不能继承的，即最终类，用于修饰方法，方法不能被子类重写
构造器子类是不继承父类的构造器的，它只是调用，如果父类的构造器带有参数，必须在子类的构造器中显示的通过super关键字调用父类的构造器并适配适当的参数列表

重写与重载

子类对父类的允许访问的方法进行重写编写，返回值和形参都不能改变
重写方法不能抛出新的检查异常或者比被重写方法声明更加宽泛的异常
访问权限不能比父类中被重写的方法的访问权限更低，父类的一个方法声明为public 子类中重写的方法就不能声明为protected
返回类型于被重写方法类型可以不相同，但是必须是父类返回值的派生类
final的方法不能被重写
static方法不能被重写，但是能够再次声明
构造方法不能被重写
重载是在一个类里面，方法名字相同，而参数不同，返回类型可以相同也可以不同
重载方法可以改变访问修饰符
重载方法可以声明新的或者更广的检查异常
方法能够在同一个类中或者一个子类中被重载
无法以返回值类型作为重载函数的区分标准

多态

多态存在的三个必要条件继承重写父类引用指向子类对象 Parent p = new Child ();
使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误，如果有再去调用子类的同名方法
如果想要调用父类中被重写的方法，使用关键字super
多态实现方式
- 重写
- 接口
- 抽象类和抽象方法

抽象类

抽象类不能实例化对象，类的其他功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样
抽象类不能实例化对象，所以抽象类必须被继承才能被使用。
使用abstract class 来定义抽象类
抽象类需要被继承之后才能创建对象
抽象方法特别的方法，该方法的具体实现由它的子类确定，那么可以在父类中声明该方法为抽象方法
abstract关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，没有方法体
```
public abstract class Employee {
  private String name;
  private String address;
  private int number;
  public abstract double computerPay ();
}


public class Salary extends Employee {
  private double salary;
  public double comupterPay () {
    	return salary / 52;
  }
}
```
封装

优点
1. 良好的封装能够减少耦合
2. 类内部的结构可以自由修改
3. 可以对成员变量进行更精细的控制
4. 隐藏信息，实现细节
实现java封装的步骤
1. 修改属性的可见性来限制对属性的访问 private
2. 对每个值属性提供对外的公共方法访问也就是创建一对赋值取值的方法，用于对私有属性的访问，因此，任何要访问类中私有成员变量的类都要通过这些getter 和 setter方法
接口

是抽象方法的集合，接口通常以interface来声明, 一个类通过继承接口的方式，从而来继承接口的抽象方法

接口的声明
```
interface 接口名称  extends 其他接口 {
  // 声明变量 
  // 抽象方法
}
```
接口是隐式抽象，声明一个接口的时候，不必使用abstract关键字

接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字

接口中的方法都是公有的
```
interface Animal {
  public void eat ();
  public void travel ();
}



public class MammalIni implements Animal {
  public void eat () {
    
  }
  
  public void travel () {
    
  }
}
```
接口允许多继承在接口的多继承中extends关键字只需要使用一次
```
public interface HocKey extends Sports, Event 
```

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

Java教程