JAVA基础知识总结
文章目录
第一章 语言特点
- 简单
- 面向对象
- 分布式
- 健壮性
- 安全
- 体系结构中立
- 可移植
- 解释型
- 较高性能
- 多线程
- 动态性(在程序运行时可以添加方法和实例变量)
要点:JAVA程序执行是将
源代码(.java文件)–>通过JAVA编译器编译–> .class文件 -->通过解释器解释运行
先编译再解释,数据大小和运算格式固定,这些也奠定了多平台、强移植的基础。
第二章 JAVA开发环境
开发体系
- java语法基础
- 运行java的虚拟机(JVM)
- java API类库
- javac(编译器)等辅助工具
1、2、3、4合称JDK (Java Development Kit):java编程最小环境
2、3合称JRE(Java Runtime Environment):java运行最小环境
版本(edition)
- java SE (Standard Edition ):基础功能,桌面级应用以及简单服务器。
- java EE (Enterprise Edition):企业级服务器。
- java ME (Micro Edition):移动端。
EE、ME都是以SE为基础。
第三章 基础语法
1、注释
- “ // ”
- “ /* (注释内容)*/ ”
- “ /* (注释内容)**/ ” 自动生成文档
2、数据类型
共四种,数字书写时可以加下划线 如 999_9 编译器仍会按照 9999编译。
数字所占内存在任何平台都相同。
-
整型
int (正负20亿)、 数字表示方法:
short(正负3.2万)、
long(九百亿亿)、 后缀L(l)如10000000000L 即为long长整型
byte(-128~127) 前缀 0b (0B) 就可以写二进制数 如 0b1001 就是十进制9
此外
前缀0x(0X)十六进制
前缀单个0 八进制
-
浮点型
float(浮点)、double(双精度浮点型)
NaN(不是一个数字)
判断一个值是否是一个数用Double.isNaN方法 返回布尔值
如 :if (x = Double.NaN) 。。。
-
字符型
char类型及单个Unicode字符。
char x = ‘A’;
或者直接用Unicode表示,一个Unicode编码是char类型,可能占用一个char类型的值也可能是两个。
Unicode编码会在代码编译前就被被转义
public static void main(String**\u005B\u00SD** args)是合法的,\u005B \u00SD分别表示[、],在编译前就会被转义为[]。
-
布尔类型(Boolean)
boolean x = false;
布尔值有且只有 true和false两个,不能用数字代替。
3、变量、常量
-
变量声明、定义。
在Java中不区分变量的声明与定义,二者可以同时进行。
double x = 1.0; // 声明并定义
1. 声明变量最好逐行进行
```java
int x, y; // 可以这样
// 为了可读性,最好这样。
int x;
int y;
- 变量开头不允许是数字,变量名中不能有空格。
-
常量
final 关键字定义常量。
public class Constants { public static void main(String[] args) { final double PI = 3.14; } }
- 常量一般大写
- 定义于main方法外。
- 同一类方法可以使用
- 若被声明为public,则其它类也能使用。
4、运算
数学函数与数学常量(Math类)
Math.sqrt(x); // x的平方根
Math.pow(x, y); // x的y平方
// 常量
Math.PI;
Math.E;
import static java.lang.Math.*;// 直接引用
数值类型转换
-
当多个数进行运算时,运算优先级
double>float>long>int
优先转换为高级别类型
-
强制类型转换
double x = 9.99; int y = (int)x; // x=9,会直接截断
Math.round方法四舍五入返回为long类型
int z = (int)Math.round(x);// 用(int)强制将long型转换为int (可能造成数据丢失)
运算符
-
结合赋值
x += 1 等价于 x = x + 1
注意:
- 如果得到的值与左侧类型不同,会强制类型转换为左侧。
- 右结合, x += y += z等价于 x += (y += z) 最好不要这样做!
-
增值符 ++ 、–
n++;//先用后加 ++n;// 先加后用
-
逻辑判断符
1、
==、!=、<、>、<=、>=…与c相同
也支持三元操作符号?:
condition ?expression: expression
若条件为真,表达式返回第一个expression,否则第二个
int x = 1; int y = 2; int n = x > y ? x : y;// 判断x是否大于y,若是则n = 1否则为 2;也可以是 int n = x > y ? 6 : 9;//若是则n等于第一个值,否则为第二个值
2、
关系判断符:&&(且)||(或)
二者遵循“短路”原则,例如 A & B ,如果A为false,则不再判断B,直接返回false。
注意 &&的运算优先级大于||
-
位运算符(TODO)
-
枚举型
个人认为是自定义变量类型,及其变量取值
如下为,变量类型是Size(类比int之类的类型),取值只有三个(而int是正负二十亿整数)
enum Size { X,XX,XXL }; //引用 Size x = Size.X
5、字符串
(仅基础概念,String类将单列学习)
1、Java字符串就是Unicode字符序列。
2、对字符串相关处理由 String这个类来处理。
3、源字符串不可改变,后续操作是构建新字符串。
4、字符串长度
String s= “” 也是s一个字符串,长度为0,里面就是什么也没有,空串也可以用Null填充
String s= “Null”,长度为1。
Java 字符串由char值序列组成,由于可能会有两个char值(代码块)对应一个Unicode值(码点)。实际长度是char值数。
⑪ is the set of octonions ⑪是由两个char值(代码块)标记的Unicode值(码点)
用codePoints方法,可以使码点与整数对应。
6、输入、输出
(仅基础概念,Scanner、PrintWriter类将单列学习)
-
标准输出流(控制台)
对于字符串 System.out.println()
-
想要读取信息进入程序,则需要用到Scanner类、
-
文件输入
Scanner in = new Scanner(Paths.get("flle.xxx"), "UTF-8");
Scanner(路径, 编码)
-
文件输出
PrintWriter out = new PrintWriter("file.xxx", "UTF-8");
7、控制流程
与c基本一样
-
条件执行
if (condition) {statement…}
if (condition) {statement…} else {statement…}
-
条件循环
- while ( condition ) {statement…}
- do {statement…} while (condition); 注意最后一个分号!!!
- continue可以跳过循环。
-
for循环
for (int i = 1; i < 10 ; i++) {statement...}
for (value : collection) {statement...}
-
switch
switch(choice) { case 1: statement... break; ... default: statement... break; }
8、数组
(仅基础概念,Arrays类将单列学习)
数组是储存同一类型值的集合
-
声明数组
int[] a;
声明了名字为a,类型都为int 的数组。int与[ ]之间没有空格!
-
初始化、匿名数组
int[] a = new int[n]// 创建名为a,储存n个int类型值的数组。 int[] a = {1, 2}//简化赋值 new int[] = {1, 2}//匿名数组 int[] a; a = new int[]{1, 2, 3}
-
数字数组初始化值均为0
-
Boolean数组初始化值为false
-
对象数组初始化为null
String[] names = new String[10]//创建包含十个“字符串”类型的数组每个字符串值为null
-
-
数组改值
int[] a = {1, 2}; a[1] = 3;//从0 开始 // a 变为{1 ,3}
-
数组拷贝、排序方法
- 拷贝
int[] a = {1, 2}; int[] b; b = Arrays.copyOF(a ,a.length)//第二个参数是新数组的长度。
如果数组是数字,多余长度为0
是字符串,多余为null
是Boolean,多余是false。
-
排序
Arrays.sort()
-
命令行参数
public class Message { public static void main(String[] args) { for (int i = 1; i < args.length; i ++) System.out.print("第"+ i + "个参数是" + args[i]); System.out.println("!"); } }
在命令行输入
java Message I LOVE YOU
将打印 第0个参数是 I 第1个参数是 LOVE 第2个参数是YOU
-
多维数组
int[][] array = { {4, 8, 6}, {5, 2, 0}, {3, 6, 9} }; /*其中 array[0][0] = 4 array[1][0] = 5 array[1][1] = 2 ... */
第四章 类与对象
1、概念
-
类(构造对象的模板)
由类构造对象的过程叫做实例(instance)
类之间的主要关系有依赖、继承、聚合(关联)
-
封装(encapsulation)
将数据和行为装进一个“包”中。
-
对象
三个主要特性
- 行为:可以完成的任务
- 状态:施加操作后返回的结果
- 标识:区分对象
对象中的数据叫做实例域,
操作类的过程叫做方法,
2、预定义类
-
构造器、对象和对象变量
构造器名字应该与类名相同。
用new+类构造器及构建了一个对象。
new Date();
对象变量:
Data birthday = new Date();
可以直接定义一个对象变量。
Data birthday ;// birthday不是一个对象,不能引用方法。 birthday = new Data();
-
更改器方法和访问器方法
对象进行访问器方法,访问器方法会产生一个新的对象(如String对象的一些更改字符串的方法)。
对象进行更改器方法,则原对象本身就会被更改。
import java.time.*;
/**
@version 2020-9-16
@author Tominochick
*/
public class CalendarTest{
public static void main(String[] args) {
LocalDate date = LocalDate.now();
int month = date.getMonthValue();
int today = date.getDayOfMonth();
date = date.minusDays(today - 1);
DayOfWeek weekday = date.getDayOfWeek();
int value = weekday.getValue();
System.out.println("周一 周二 周三 周四 周五 周六 周日");
for (int i = 1; i < value; i++)
System.out.print(" ");
while (date.getMonthValue() == month){
System.out.printf("%3d", date.getDayOfMonth());
if (date.getDayOfMonth() == today){
System.out.print("*");
}
else {
System.out.print(" ");
}
date = date.plusDays(1);
if (date.getDayOfWeek().getValue() == 1)
System.out.println();
}
if (date.getDayOfWeek().getValue() != 1)
System.out.println();
}
}
3、自定义类
格式
class Classname()
{
实例域;
field1
...
constructer
构造器;
...
method
方法;
...
}
4、静态域与静态方法
static 修饰符
- 静态域
类中的某个实例域如果被static修饰,则每一个类中只有一个唯一的域。
如果一个类有100个对象,这100对象可以有100个实例域,但只有一个静态域,不属于任一对象,只属于类本身。
所有对象共享,也都能进行更改。
- 静态方法
与静态域相似,属于类,而不是属于具体对象。
第五章 继承
extends 单继承 A只能继承一个B
implements 多继承 A 能继承 B、C等多个类
class 子类 extends 父类{}
class A implements B, C{}
super 使用父类的方法
this 使用自己的方法
final 使用final修饰类,这类不会被继承,成为“最终类”
第六章 多态
多态 :
同一方法对不同对象采用多种不同的行为方式;
一个对象的实际类型是确定的,但可以指向对象的引用的类型是多样的。
// Student extends Person
Student A = new Student();
Person A = new Student();
Object A = new Student();
对象变量A(引用类型)是多态的,可以是Person、Object
对象变量能使用的方法取决于其 引用类型 和 子类方法 是否被重写。
例如:Person A = new Student();
如果父类Person定义了f()方法,其子类Student重写了f()方法,则A.f()实现的是子类Student里的f()方法。
如果父类Person定义了f()方法, 其子类Student没有f()方法,则A.f()实现的是父类Person里的f()方法。
如果父类Person未定义f()方法, 其子类Student有f()方法,则A.f()无法调用,需要强制类型转换。
1、方法重写
在具有继承关系的前提下,子类重写父类的方法。
- 方法名、参数列表必须相同。
- 修饰符范围扩大不能缩小 public > protected > default > private
- 异常范围可以缩小,不能扩大 ClassNotFoundException -->Exception(大)
2、类型转换
-
instanceof判断子夫关系
A instanceof B; A 是否为B 的子类,是,返回true,
A<=B
-
类型转换
// Student extends Person Person A = new Student(); ((student) A).f();
3、抽象类、接口
用abstract修饰类,起占位作用,类的方法由子类实现。
public abstract class Action
{
public abstract void f1();// 含有抽象方法,则该类必须是抽象类
public void f2();// 抽象类中可有有普通方法
}
-
普通类
只有实现
-
抽象类
有实现,有规范(抽象方法)
-
接口
只有规范。实现规范和实现分离
public interface UserService
{
//接口中的方法都是public abstract(默认 不用写)
void f1(x);
void f2(y);
...
}
接口需要有实现类,必须实现接口中的所有方法。
实现类命名以impl结尾
public class UserServiceImpl implements Userservice
{
@override
void f1(x);
@override
void f2(y);
...
}
implements后可以有多个接口
第七章 异常
try、 catch、 finally、 throw、 throws
try
{
//异常监视区
}
catch(Throwable x)// 第一个参数是异常类型, 第二个参数是异常变量
{
//处理区
}
// 可catch多个异常范围最小的应该最先捕获 Throwable > Execption > IOException...
finally
{
//善后区,无论是否有异常,都会执行。
}
在函数中抛出异常
public void f()
{
throw new Expection();
}
如果在异常出现的类中无法处理此异常,可以在类层面上抛出异常
public class person throws IOExecption, RuntimeExecption
{
...
}