Java 概念简述
基本环境
JVM:Java虚拟机(Java程序是运行在JVM上的,不同平台的JVM实现了Java程序的跨平台运行)
JRE:Java运行环境(JRE = JDK + 核心类库和相关文件)
JDK:Java开发工具包(JDK = Java开发工具)
标识规范
类名:驼峰命名法(首字母大写)
方法:驼峰命名法(首字母小写)
变量:驼峰命名法(首字母小写)
代码注释
单行注释:
//我是单行注释
多行注释:
/*
我是多行注释
我是多行注释
*/
文档注释:
/**
*我是文档注释
*我是文档注释
*/
Java 数据类型
基本数据类型
整型
| 数据类型 | 占用空间 |
|---|---|
| byte | 1B |
| short | 2B |
| int | 4B |
| long | 8B |
浮点型
| 数据类型 | 占用空间 |
|---|---|
| float | 4B |
| double | 8B |
字符型
| 数据类型 | 占用空间 |
|---|---|
| char | 2B |
布尔型
| 数据类型 | 占用空间 |
|---|---|
| boolean | 1B |
| boolean | 4B |
复杂数据类型
数组
数组是存放同类数据类型的数据的集合,本质是对象,数组元素可以是任何数据类型,只有都相同就行
int[] a = new int[3]; //数组定义
int[] a = {10,20,30}; //数组初始化
a[0] = 10;a[1] = 20;a[2] = 30; //数组赋值
for(int i = 0;i < a.lenght;i++) { //数组遍历
System.out.println(a[i]);
}
for(int temp:a) {
System.out.println(temp); //数组遍历
}
System.arraycopy(a,1,b,0,2); //拷贝数组(从数组a中1号位置开始拷贝到数组b的0号位置,拷贝长度为2个)
System.out.println(Arrays.toString(a)) //打印数组
Arrays.sort(a) //数组排序
Arrays.binarySearch(a,100) //查询数组(查询的数组必须是有序数组)
Arrays.fill(a,100) //填充数组
容器
容器时存放数据的集合,本质是对象
//List元素可以重复,存储有顺序
List list = new ArrayList(); //定义ArrayList容器
//ArrayList底层是数组实现,查询效率高,增删效率低,线程不安全
List list = new LinkedList(); //定义LinkedList容器
//ArrayList底层是双向链表实现,查询效率低,增删效率高,线程不安全
List list = new Vector(); //定义Vector容器
//ArrayList底层是数组实现,相关方法增加了同步检查,线程安全,效率都很低
//容器支持的方法,ArrayList、LinkedList、Vector容器均支持
list.size(); //获取容器的元素个数
list.isEmpty(); //判断容器是否为空
list.add(value); //在容器末尾加入value元素
list.add(index,value); //在指定索引index出加入value元素(索引和数组一样)
list.remove(value); //移除容器中value元素
list.set(index,value); //在指定索引index设置元素为value(索引和数组一样)
list.get(index); //获取指定索引index处的元素
list.indexOf(value); //查找value元素(从左往右找)
list.laseIndexOf(value); //查找value元素(从后往前找)
list1.containsAll(list2); //判断list1容器的元素是否完全包含list2容器元素
list1.addAll(list2); //把list2容器中的元素都加入到list1容器中
list1.removeAll(list2); //把list1容器中和list2中元素相等的元素都删除
list1.retainAll(list2); //把list容器的元素变为list1容器和list2容器共有的元素
//Set元素不可重复,存储无顺序
Set s = new HashSet();
//和list一致
s.size(); //获取容器的元素个数
s.isEmpty(); //判断容器是否为空
s.add(value); //在容器末尾加入value元素
s.add(index,value); //在指定索引index出加入value元素(索引和数组一样)
s.remove(value); //移除容器中value元素
s.set(index,value); //在指定索引index设置元素为value(索引和数组一样)
s.get(index); //获取指定索引index处的元素
s.indexOf(value); //查找value元素(从左往右找)
s.laseIndexOf(value); //查找value元素(从后往前找)
s.containsAll(list2); //判断list1容器的元素是否完全包含list2容器元素
s.addAll(list2); //把list2容器中的元素都加入到list1容器中
s.removeAll(list2); //把list1容器中和list2中元素相等的元素都删除
s.retainAll(list2); //把list容器的元素变为list1容器和list2容器共有的元素
//Map元素是键值对,键不可重复,如果键重复则后者的值替换前者
Map m = new HashMap();
//HashMap :效率高,线程不安全,允许key和value为空
//Hashtable:效率低,线程安全,不允许key和value为空
m.put(key,value); //添加键值对
m.putAll(m1); //将m1容器的元素全部加入m容器
m.remove(key,value); //移除键值对
m.size*(); //获取容器的大小
m.isEmpty(); //判断容器是否为空
m.containsKey(key); //判断容器中是否有key
m.containsValue(value)//判断容器中是否有value
m.keySet(); //将m容器中的key全部存入Set容器中
数据类型转换
自动数据类型转换
表数范围小的数据类型可以自动转换为表数范围大的数据类型
强制数据类型转换
直接舍弃不符合目标数据类型的数据精度
当数据类型无法表示数据大小时会发生溢出,数据会改变
Java 运算符号
算数运算符
| 运算符号 | 功能作用 |
|---|---|
| + | 加 |
| - | 减 |
| * | 乘 |
| / | 除 |
| % | 余 |
赋值运算符
| 运算符号 | 功能作用 |
|---|---|
| += | 加赋值 |
| -= | 减赋值 |
| *= | 乘赋值 |
| /= | 除赋值 |
| %= | 余赋值 |
关系运算符
| 运算符号 | 功能作用 |
|---|---|
| == | 等于 |
| != | 不等 |
| > | 大于 |
| < | 小于 |
| >= | 大等 |
| <= | 小等 |
逻辑运算符
| 运算符号 | 功能作用 |
|---|---|
| && | 短路与 |
| || | 短路或 |
| ! | 非 |
| & | 位与 |
| | | 位或 |
| ~ | 位反 |
| ^ | 异或 |
| << | 左移 |
| >> | 右移 |
条件运算符
| 运算符号 | 功能作用 |
|---|---|
| ? : | 条件判断 |
Java 输入输出
输入
输出
Java 流程控制
条件判断语句
if 语句
(1)单条件判断
if(conditon){
"sentence";
}
(2)双条件判断
if(conditon){
"sentence";
}else {
"sentence";
}
(3)多条件判断
if(conditon){
"sentence";
}else if {
"sentence";
}else {
"sentence";
}
switch 语句
switch(condition){
case value1:
"sentence";
case value2:
"sentence";
default:
"sentence";
}
循环控制语句
for 语句
for(condition){
"sentence";
}
while 语句
while(condition){
"sentence";
}
特殊控制语句
break :跳出一层循环或跳出switch语句
continue:跳过本轮循环continue语句后面的内容
Java 函数方法
方法定义
"return_type" "function_name"("parameter"){
"sentence";
}
方法重载
方法的方法名相同,方法参数类型或参数数量不同在同名方法构成重载
程序根据参数的不同调用匹配的重载方法(只有返回值类型不同的方法不能构成重载)
Java 异常处理
Java 类和对象
封装
访问权限修饰符
| 修饰符 | 同类 | 子类 | 同包的类 | 不同包的类 |
|---|---|---|---|---|
| private | 1 | 0 | 0 | 0 |
| default | 1 | 0 | 1 | 0 |
| protected | 1 | 1 | 1 | 0 |
| public | 1 | 1 | 1 | 1 |
工作规范
(1)类的属性直接使用private访问权限(使用get()和set()设置和获取属性值)
(2)利用IDEA的Generate中Getter和Setter可以自动生成对应属性的get()和set()
构造方法
(1)构造方法有返回值,但不能手动定义返回值类型,不能使用return语句(系统规定自返回本类的对象)
(2)当没有手动定于构造方法时,系统自动添加一个无参构造方法
(3)构造方法名称必须和类名保持一致
(4)构造方法使用new关键字调用
关键字
(1)this:保存当前对象地址的变量(在普通方法中:this总是指向调用该方法的对象)(在构造犯法中:this总是指向正要初始化的对象)
(2)static变量:静态变量从属于类,只有一份,使用类名调
static方法:静态方法从属于类,只有一份,使用类名调用(statci方法不可直接访问非static成员)
(3)导入某个类:import static java.lang.Math.random;
导入全部类:import static java.lang.Math.*;(导入的非同名类直接访问,同名类包名加类名访问)
(4)java.lang:提供常用功能类的包(默认每个java文件中自动被导入)
java.awt :提供窗口构建类的包
java.net :提供网络操作类的包
java.io :提供输入输出类的包
java.util:提供实用工具类的包
(5)final变量:一旦赋值,不能被重新复赋值
final方法:不可被子类重写,可以重载
final的类:不能被继承
继承
传统继承
(1)子类继承父类所有方法和属性的操作,使用extern关键字继承
(2)java类是单继承,接口是多继承,java类没有指定继承的父类时默认继承Object类
(3)super可以看成父类对象的引用,可以用来在子类中调用父类中被子类重写过的属性和方法
(4)super()可以看成父类对象的构造方法的引用,当在子类构造方法中未手动调用父类构造方法时,系统默认自动调用
//继承示例
public class Animal {
int animal;
public void sleep() {
System.out.println("Animal.sheep!!!");
}
}
class Dog extends Animal {
System.out.println(animal);
Animal.sleep();
}
//super示例
public class Animal {
int animal;
public void sleep() {
System.out.println("Animal.sheep!!!");
}
}
class Dog extends Animal {
int animal;
public void sleep() {
System.out.println("Dog.sheep!!!");
}
System.out.println(super.Animal);//使用父类的animal变量
super.sleep(); //调用父类中的sheep()
}
组合继承
(1)类的属性是另外一个类的对象,从而达到子类父类继承的效果
//组合示例
public class Animal {
String name;
public void sleep() {
System.out.println("Animal.sheep!!!");
}
}
class Dog {
Animal animal = new Animal();
System.out.println(name);
animal.sleep();
}
多态
(1)具有相同父类的子类由于重写了父类的方法实现了该方法咋子类中表现不同的操作
public class Animal {
public void sleep() {
System.out.println("Animal.sheep!!!");
}
}
class Dog extends Animal {
@Override
public void shout() {
System.out.println("Dog sheep!!!");
}
}
class Cat extends Animal {
@Override
public void shout() {
System.out.println("Cat sheep!!!");
}
}
抽象
抽象类
(1)包含抽象方法的类称为抽象类,包含抽象方法的类必须是抽象类
(2)抽象类只能用来被继承,不能实例化对象(抽象类的构造方法仍然存在但只能是被子类调用)
(3)抽象类的抽象方法在子类中必须被实现
抽象方法
(1)抽象方法没有方法体,只有声明,使用abstract关键字修饰
(2)父类提供方法框架规范,各个子类中各自实现该方法的具体内容(多态典型应用)
public abstract class Animal {
public abstract void shout();
public void sleep() {
System.out.println("Animal.sheep");
}
}
class Dog extends Animal {
@Override
public void shout() {
System.out.println("Dog shout!!!");
}
Animal.sleep();
}
class Cat extends Animal {
@Override
public void shout() {
System.out.println("Cat shout!!!");
}
Animal.sleep();
}
接口
接口概念
传统接口:
(1)定义一种类的规范,实现规范和实现分离的作用,使用interface定义接口,使用implements实现接口
(2)接口属性类型必须是public static final类型,系统会自动加上此类型说明
(3)接口方法类型必须是public abstract 类型,系统会自动加上此类型说明,接口中的方法必须实现
(4)接口可以多继承,一个类也可以同时实现多个接口,一个接口也可以被多个类实现
扩展接口:
(1)可以定义默认方法:默认方法可在接口中实现也可在实现类中重写
(2)可以定于静态方法:静态方法可在接口中实现,使用接口名调用;静态方法也可在实现类中实现,使用类名调用
接口定义
interface A {
int a;
void way_a();
}
interface B {
int b;
void way_b();
}
interface C extends A,B {
int c;
void way_c();
}
接口实现
public class TestInterface implements C {
@Override
public void way_a() {
System.out.println("a");
}
@Override
public void way_b() {
System.out.println("b");
}
@Override
public void way_c() {
System.out.println("c");
}
}
Java 的多线程
进程:资源分配的最小单位
线程:任务执行的最小单位
创建线程
Thread 方法
通过创建Thread类的实例创建线程,使用继承Thread类使用start()启动线程,run()操作线程
public class TestThread extends Thread {
public static void main(String[] args) {
TestThread t1 = new TestThread();//创建线程对象t1
t1.start();//启动线程t1,自动调用run()
TestThread t2 = new TestThread();//创建线程对象t1
t1.start();//启动线程t2,自动调用run()
}
@Override
public void run() { //线程处理方法
for(int i = 0;i < 10;i++) {
System.out.println(this.getName() + ":" + i);
}
}
}
Runnable接口方法
通过创建Thread类的实例创建线程,把实现Runnable接口的对象作为Thread实例的参数
public class TestThread implements Runnable {
@Override
public void run() {
for(int i = 0;i < 10;i++) {
System.out.println(this.getName() + ":" + i);
}
}
public static void main(String[] agrs) {
TestThread t = new TestThread();
Thread t1 = new Thread(t);
t1.start();
Thread t2 = new Thread(t);
t2.start();
}
}
Lambda方法
通过匿名内部类方式实现
//正常模式
public class TestThread {
public static void main(String[] args) {
new Thread(new Runnable(){
@Override
public void run() {
for(int i = 0;i < 10;i++) {
System.out.println(this.getName() + ":" + i);
}
}
}).start();
}
}
//简写模式
public class TestThread {
public static void main(String[] args) {
new Thread(()->{
@Override
public void run() {
for(int i = 0;i < 10;i++) {
System.out.println(this.getName() + ":" + i);
}
}
}).start();
}
}
终止线程
(1)使用一个boolean变量终止线程的run()
生命周期
线程方法
| 方法 | 功能 |
|---|---|
| isAlive( ) | 判断线程是否活着 |
| getPriority( ) | 获取线程优先级数值 |
| setPriority( ) | 设置新车优先级数值 |
| setName( ) | 设置线程名称 |
| getName( ) | 获取线程名称 |
| currentThread( ) | 获取当前运行的线程对象 |
(1)线程优先级使用数字表示,范围1-10,默认5(优先级只用于线程被调用的概率,并非高优先级线程先调度)
线程同步
(1)当多个线程同时操作一个资源时可能会发生错乱,使用线程同步来给资源上锁能解决此问题,关键字synchronized
@Override
public void run() {
synchronized(account) {
if(account.money = drawingNum < 0) {
System.out.println("钱不够");
return;
}
try {
Thread.sleep(1000);
} catch(InterruptedException e) {
e.printStackTrace();
}
account.money -= drawingNum;
expenseTotal += drawingNum;
}
}