第一部分
关键字
八大基本类型关键字:byte,short,int,long,float,double,char,boolean
分支:if,else 选择:switch,case,default 循环:for,while,do
结束;break 跳过continue
静态 static 最终 final
公共 public 同包使用 protected 私有 private
包 package 类class ,导入 import
新建 new 返回值 return 无返回值 void
抽象 abstract 继承 extends 父类super 本类 this
接口 interface 实现接口 implements
异常 抛出 throws 单句抛出 throw 捕获 try,catch,finally
同步锁 synchronize
assert , const, enum, goto, instanceof ,native,strictfp ,transient,volatile,
true,false,null (也不能作为关键字)
标识符号
①以字母,数字,下划线(_),$ 组成, 不能含有@或英文句号
②不能以数字开头
③不能是关键字
④区分大小写
⑤见名知意
注释
单行注释 // 内容
多行注释 /* 内容 /
文档注释 /* 内容 可以写名字和日期 */
变量/常量
变量的值可以改变,①必须是有效的标识符,②不能用关键字定义,③不能重复
常量的值不可以改变
基本类型,
byte,short,int,long,float,double,char,boolean
类型转换
大转小 需要强转 可能会出现错误
小转大 直接转
分支结构
单分支
if(判断条件){满足条件执行的语句}
多分支
if(判断条件){满足条件执行的语句
}else {不满足条件执行的语句}
嵌套分支
if(判断条件1){满足条件1执行的语句
}else if(判断条件2){满足条件2执行的语句
}else if(判断条件3){满足条件3执行的语句
}else{不满足所有条件执行的语句}
选择结构
switch(a){
case 1: 执行语句 ;break;
case 2: 执行语句 ;break;
case 3: 执行语句 ;break;
default :执行语句;
}
判断a的值符合哪一个就执行哪一条语句,要用break结束
循环结构
for循环
结构
for( 开始条件;判断条件;更改条件){循环语句}
while循环
结构
while(循环条件){循环语句}
do-while循环
结构
do{循环语句}while(循环条件);
至少执行一次
数组
数组创建后,长度固定
创建方式
- 数组类型[] 数组名 ={数组内容};
- 数组类型[] 数组名 =数组类型[]{数组内容};
- 数组类型[] 数组名 =数组类型[数组长度]{};
第二部分
面向对象
面向三大特征 :
- 封装
- 继承
- 多态
对象的三个特点 : 对象的状态 , 对象的行为 ,对象的标识
封装
封装以后要提供对应的set()与get()
构造函数(构造方法)
构造函数的方法名与其类名相同
创建方式
修饰符 方法名 (参数列表){代码}
代码块
构造代码块 类里方法外
局部代码块 方法里
静态代码块 类里方法外 用static修饰
执行的顺序,静态代码块->构造代码块->构造方法->局部代码块
static / final
static 静态 在创建对象是会优先加载
final 最终 不允许改变被其修饰的内容
继承
继承可以继承私有属性,提供get()与set()后可以在子类使用
继承只支持单继承
子类不能调用父类的私有方法
继承后一般会重写父类的方法 用@Override 标明重写的方法
方法的重写规则 两同两小一大
- 两同 方法名与参数列表相同
- 两小 子类返回值类型小于父类返回值类型
子类抛出异常小于父类抛出异常 - 一大 子类的修饰符权限要大于父类修饰符权限
调用父类的成员变量或方法用 super.
重写/Override
一般继承就会有重写,遵循规则两同两小一大
意义 方便对功能进行拓展和修改
重载/@Overload
在一个类中有很多同名的方法但参数列表不同的方法
意义:方便外界调用方法,无论输入什么参数类型都能调用
多态
- 前提①是继承②要有方法的重写
创建形式 父类引用指向子类对象 创建格式 Animal a = new Cat();
编译看左边,运行看右边 - 多态的使用规则
成员变量: 使用的是父类的
成员方法: 由于存在重写现象,所以使用的是子类的
静态成员: 随着类的加载而加载,谁调用就返回谁的
转型的规则
- 向上转型 多态的创建就是向上转型 把子类看成是父类类型
- 向下转型 多态创建成功后,子类想要调用自己的特有的功能就需要向下转型
Parent p = new Child();//向上转型，此时，p是Parent类型
Child c = (Child)p;//此时，把Parent类型的p转成小类型Child
异常
不可人为解决的异常
能人为解决的异常
- 抛出 throws 可以抛出一个或多个 不知道在哪里会发生错误就抛出
- 捕获 try-catch-finally
try {可能出现异常的代码}
catch(异常类型 异常命名){如果发生异常在控制台输出异常种类}
finally{执行代码时必定执行的语句}
程序错误分为三种：
编译错误(checked异常)；
运行时错误（unchecked异常）；
逻辑错误； - 编译错误是因为程序没有遵循语法规则，编译程序能够自己发现并且提示我们错误的原因和位置，这个也是大家在刚接触编程语言最常遇到的问题。
- 运行时错误是因为程序在执行时，运行环境发现了不能执行的操作。
- 逻辑错误是因为程序没有按照预期的逻辑顺序执行。异常也就是指程序运行时发生错误，而异常处理就是对这些错误进行处理和控制。
抽象类
abstract修饰的就是抽象
抽象方法格式 修饰符 abstract 返回值类型 方法名 (参数列表);
抽象类里可以没有抽象方法,但抽象方法必须放在抽象类里
子类继承抽象类以后需要把所有抽象方法全部重写,要不子类还是抽象类
抽象类对象的创建必须使用多态 抽象类不能创建对象 抽象类不能被实例化
- private：被私有化后，子类无法重写，与abstract相违背。
- static：静态优先于对象存在，存在加载顺序问题。
- final：被final修饰后，无法重写，与abstract相违背。
接口
interface 修饰的就是接口
接口创建格式 interface 接口名{代码}
- 通过interface关键字来定义接口
- 通过implements让子类来实现接口
- 接口中的方法全部都是抽象方法(JAVA8)
- 可以把接口理解成一个特殊的抽象类(但接口不是类!!!)
- 类描述的是一类事物的属性和方法,接口则是包含实现类要实现的方法
- 接口突破了java单继承的局限性
- 接口和类之间可以多实现,接口与接口之间可以多继承
- 接口是对外暴露的规则,是一套开发规范
- 接口提高了程序的功能拓展,降低了耦合性
总结:接口里是没有构造方法的
在创建实现类的对象时默认的super()，是调用的默认Object的无参构造
总结:接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，
默认会加上：public static final
总结:接口里的方法，默认就都是抽象的，如果你不写明是abstract的，那会自动补齐。
例如：public abstract void save
第三部分
顶级父类
Object类:每个类都使用Object作为超类.所有对象(包括数组)都实现这个类的方法.
在Object类中的方法: toString() 默认是会返回地址值,所以一般会重写toString()
hashCode() 每个对象调用都会有一个哈希码值,不同对象之间可能会生成相同的哈希码值
equals() 比较两个对象的数据是否想等 底层的默认比较也是用== 来比较
正则表达式
正则表达式是用来规定录入数据的样式,(比如手机号码必须为11位数字)
使用方法,在使用时,代码中的\要再使用\转义一次
包装类,自动装箱/自动拆箱
- 自动装箱：把 基本类型 包装成对应的 包装类型 的过程
Integer a = 5;//a是引用类型，引用了包装对象的地址。
编译器会完成对象的自动装箱：Integer a = Integer.valueOf(5); - 自动拆箱：从包装类型的值，自动变成 基本类型的值
int i = a;//a现在是包装类型，没法给变量赋值，需要把5取出来。
编译器会完成自动拆箱：int i = a.intValue();
BigDecimal：常用来解决精确的浮点数运算不精确的问题(在除法是要有舍入方式)
方式一 :
BigDecimal(double val)
将double转换为BigDecimal,后者是double的二进制浮点值十进制表示形式,有坑!
方式二 :
BigDecimal(String val)
将String类型字符串的形式转换为BigDecimal
File文件类
操作数据
IO流
需要用多态来创建对象
字节输入流:普通:InputStream
创建方式: InputStream in = new FileInputStream(" “);
高效:BufferInputStream
创建方式:InputStream in = new BufferInputStream(new FileInputStream(” "))
字节输出流:普通:OutputStream
高效:BufferOutputStream
字符输入流:普通:Reader
高效:BufferedReader
字符输出流:普通:Writer
高效:BufferedWriter
序列化与反序列化
需要用多态创建对象
- 序列化是把输入的数据转换成字节码文件存入文本之中
序列化方式:ObjectOutputStream - 反序列化是把文本中的字节码文件转换成可以看懂的数据输出到控制台
反序列化方式:ObjectInputStream
集合
Collection接口 下有 List接口和Set接口
- List接口 [数据有下标,有序,可重复]
ArrayList子类 [数组结构]
LinkedList子类 [链表结构] - Set接口 [数据无下标,无序,不可重复]
HashSet子类
Map接口 [键值对方式存数据]
- HashMap子类
进程/线程/多线程
进程是正在运行的程序 特点:独立性 动态性 并发性
线程是进程中一个小的运行单位
线程的五态:新建 就绪 运行 阻塞 终止
多线程是指多个线程同时执行同一动作,比如四个售票处,同时出售100张票 (票只有100张)
多线程的创建方式,
- 方式一:类继承Thread然后创建多个线程对象,实现多线程
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread(); - 方式二:类实现Runnable,然后创建一个线程对象,绑定Thread类
MyRunnable target = new MyRunnable();
Thread t1 = new Thread(target);
Thread t2 = new Thread(target); - 方式三:线程池
继承Runnable的类创建对象,创建线程池,调用线程池
TickR3 target = new TickR3();
ExecutorService pool = Executors.newFixedThreadPool(线程数);
pool.execute(target)
同步锁synchronize/线程安全问题:
在多线程时,数据的访问过于迅速会导致数据产生错误,就有了同步锁
使用之后会使线程变慢,但是更安全,
使用方式 先创建锁对象,然后使用锁 Object o = new Object;synchronize(o){多线程程序}
设计模式
单例设计模式, 饿汉式 提供私有构造方法
创建私有静态对象
提供公有静态调用对象的方法{直接返回创建的对象}
懒汉式 提供私有构造方法
静态私有引用变量
创建锁对象
静态公有锁方法{判断是否创建过对象,没有就创建对象,有就返回对象}
注解
JDK注解 @Override 重写
元注解 @Target 注解使用的地方(类上,方法上,属性上)
@Retention 注解的生命周期(源文件中,字节码文件中,运行中)
自定义注解 自己使用元注解来新定义的注解
反射
- 普通反射 获取字节码对象 Class<?> clazz = Preson.class;
获取构造方法 Constructor<?>[] cs = clazz.getConstructors();
获取成员方法 Method[] ms = clazz.getMethods();
获取成员变量 Field field = clazz.getFields()
创建对象 Object o = clazz.newInstance() - 暴力反射:可以反射私有 反射私有使用时要设置私有可见
反射方式 获取字节码对象 Class<?> clazz = Preson.class;
获取私有属性 Field field = clazz.getDeclaredField(“私有属性名”)
设置私有可见 field.setAccessible(true)
也要设置私有可见 method.setAccessible(true)
内部类
在类里再创建一个类,
- 内部类可以调用外部类的资源,(包括私有资源)
- 外部类只能创建对象调用内部类的功能
当内部类被设置私有时,要在外部类中设置get() 让其他类可以使用这个外部类的内部类
当内部类被设置静态时,用类名就可以直接调用内部类的方法
当内部类被创建在方法中时被称为局部内部类 调用局部内部类也要在方法中创建对象
8167
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
