javase
> java语言特点
> java开发环境 -jdk jre jvm
> 命名
> 数据类型
后缀
字面值
类型转换
**.. 查看数据类型的范围
**.. 用户输入
**.. 查看数据的类型
** 运算规则
> 运算符
> 分支
> 循环
break/continue
随机数
> 变量
成员变量
局部变量
> 方法
方法重载
> 数组
定义
**.. 数组内存
** 数组下标越界
遍历
工具类 Arrays
tostring
sort
copyOf
** println对char数组进行了数组遍历, 输出时会打印所有值
> OOP
对面向对象的了解 -是什么,特点,特征,封装,继承,多态
单一对象内存管理
* 封装
* 继承
* 多态 同一个实体同时具有多种状态, 不同时期所代表的对象不同 不同数据类型的实体提供统一接口
* 抽象类
* 接口
构造方法
构造代码块
局部代码块
* this super
override
* static
静态代码块
* final
> 异常
RunTimeException Exception
* 捕获异常
* 抛出异常
* 自定义异常 使用
> 访问控制符
public protected default private
> 设计模式
* 单例模式
.. 饿汉式
.. 懒汉式 --解决线程安全
> API
* Object
.. toString
.. equals
.. hashCode
.. getClass
* Class
.. getComponentType()
* System
.. currnetTimeMillis()
.. in()
.. exit()
* String
.. getbytes() new String(byte[] b)
.. length()
.. replace()
.. toCharArray() new String(char[] c)
.. trim()
.. valueOf()
.. lastIndexOf() "lvjing".lastIndexOf("vj",2) 1 从指定位置开始反向搜索, 把vj看做一个字母v,看v后面是不是j 如果不是返回-1 如果是返回v的位置
* StringBulider/StringBuffer
.. append()
* Number
* Integer
.. new Integer() int/String -> Integer
.. intValue() Integer -> int
.. valueOf() int/String -> Integer
.. parseInt() String -> int
装箱
Integer i1=100,i2=100,i3=300,i4=300;
i1==i2 true i3==i4 false
在-128到127范围内直接在cache内取 大于就创建对象 比较的还是地址值
Integer a = new Integer(3);
Integer b = 3;
int c = 3;
a==b false地址值 a==c true b==c true 这里进行比较时 包装类转换为基本类型再进行比较
拆箱
String/StringBuilder/StringBuffer
* a. 执行速度 StringBuilder > StringBuffer > String
* b. 线程安全: StringBuilder不安全 StringBuffer安全-使用了同步锁
* c. 试用场景: String-少量字符操作 , StringBuilder-单线程下载字符缓冲区大量字符操作 , StringBuffer-多线程下字符缓冲区打了字符操作
Integer
* new Integer() intValue() valueOf() parseInt() -128~127
* Integer a = new Integer("123"); Integer b = new Integer("123"); --false
* Integer c = 123; Integer d = 123; --true
* Integer e = 500; Integer f = 500; --false
* Integer g = new Integer("123"); int h = 123; --true
* Integer i = 500; int j = 500; --true
* Date
.. getTime()
.. toString()
* SimpleDateFormat
.. new SimpleDateFormat("yyyy-MM-dd")
.. parse()
.. format()
* BigDecimal/BigInteger
.. new BigDecimal(String s) 精确
.. add
.. subtract
.. multiply
.. divide
> stream 输入 输出
* File
new File(String path)
mkdirs createNewFile getAbsolutePath listFiles delete length
* io
字节流
InputStream FileInputStream BufferedInputStream
read() read(byte[]) close()
OutputStream FileOutputStream BufferedOutputStream
write(int) write(byte[]) close() flush()
BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("D:\\iotest\\lvjing.txt"))
字符流
Reader BufferedReader InputStreamReader FileReader
read() read(char[]) readLine() close()
Writer BufferedWriter OutputStreamWriter FileWriter
write() newLine()
BufferReader br = new BufferedReader(new FileReader("path"));
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
转换流
InputStreamReader isr = new InputStreamReader(new FileInputStream("path","Unicode/utf-8"));
对象流
序列化流 反序列化流
serialVersionUID
序列化: ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(path))
反序列化: ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path))
字节流 字符流
输入流
字节流只能 一个字节一个字节的读 read()
字符流可以 一个字节一个字节的读 read() 也可以一行一行读 BufferedReader.readLine()
输入流 与 输出流 可以传输的 数据(参数)
wirte write(int) write(char[]) wirte(String)
read read() read(char[])
char[] ch = "ljving".toCharArray();
Stream 的 read write
字节流 字符流 文件 序列化
要么 抛出异常throws 要么捕获异常try{}catch(){}
> 递归
lvjing(){ lvjing(); }
递归与迭代
> 泛型
编译时检查类型,运行时类型擦除
泛型类 class Ljving<T>{}
泛型方法 Public <T>void doLvjing(T t){}
集合泛型 Map<String,Integer>
类型擦除 编译检查类型, 运行Object
泛型通配符 ? ? extends T ? super T
> 集合
Collection
List
ArrayList
LinkedList
Set
HashSet
TreeSet
Map
hashMap
Collection
add remove size clear isEmpty toArray contains equals hashCode addAll containsAll removeAll iterator
Iterator hasNext next remove\
迭代
List 特点
add(index,element) get set subList addAll listIterator
迭代
.. ArrayList :
.. LinkedList : addFirst addLast getFirst getLast removeFirst removeLast
不必事先估计存储空间
ArrayList 和 LinkedList
Set 特点
add addAll contains isEmpty remove iterator size toArray
迭代
.. hashSet :
Collestions Collection集合的 静态操作
sort(List) max(Collection) min(Collection) swap(List,int,int)
addAll(Collection,elements)
Map
Map<K,V> 特点:
put get clear remove size values keySet entrySet
迭代: Map m = new Map();
Colleciton<V> con = m.Values(); value
Set<K> con = m.keySet(); key value = m.get(key)
Set<Map.Entry<K,V>> con = m.entrySet(); key,value
Map.Entry接口 me -> 方法 me.getKey() me.getValue()
HashMap
初始容量
加载因子
哈希表
存储数据
哈希函数 hash(key)%n n-数组大小
哈希碰撞 解决哈希碰撞 数组+链表 就是HashMap
> Thread
进程 线程 并发 并行 多线程 线程状态
多线程的实现 : 继承Thread类 实现Runnable接口 实现Callable接口 线程池
Thread
start run stop sleep getId getName setName currentThread
Runnable
Callable
call()
FutureTask(Callable c)Runnable接口的实现类 Thread(Runnable r)
线程池
实现Runnable接口
ExecutorService es = Executors.newFixedThreadPool(10)
ThreadPoolExecutor tpe = (ThreadPoolExecutor)es
tpe.executor(Runnable r)
* 多线程实现 继承Thread类 实现Runnable接口 实现Callable接口 线程池
* 继承Thread类
* currentThread
* getId getName setName
* run
* start
* stop
* sleep
*
* 实现Runnable接口
* 定义类实现Runnable接口,重写run方法,创建实现类对象,
* 使用Thread对象传入Runnable接口的实现类,使用Thread的start方法启动线程执行run方法
* Thread.currentThread()获取当前线程对象 .getName() 获取名字
*
* 实现Callable接口
* 定义类 实现Callable接口 重写call方法 有返回值 异常 创建对象
* 使用FutureTask对象传入Callable接口的实现类,
* 使用Thread对象传入FutureTask对象
* 使用Thread的start方法启动线程执行call方法
* Thread.currentThread()获取当前线程对象 .getName() 获取名字
* Callable接口 类似于Runnable接口
* FutureTask 可以包装Callable或Runnable对象 也是Runnable接口的实现类
* Thread 创建对象 参数可以是 Runnable 可以把FutureTask对象作为Thread对象的参数创建对象
*
* Runnable 接口 和 Callable 接口
* Callable接口 有返回值, 可以向上抛异常 捕获 call方法
* Runnable 异常只能内部消化 run方法
*
* 线程池
* 创建Runnable的实现类, 重写run方法
* 使用Executors中的newFixedThreadPool(10) 创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。
* 返回 ExecutorService 接口类型 将 此类型转换为ThreadPoolExecutor类型
* 执行方法executor() 执行任务开启线程
* Executors中的newFixedThreadPool(10) 创建线程池 返回 ExecutorService接口类型
* ThreadPoolExecutor 是ExecutorService接口的实现类
> Synchronized
解决的问题:
异步锁 :
同步锁 : 排队的效果
同步方法 普通方法 静态方法
同步代码块
锁对象 this 类名.class
共享资源:
静态的 锁对象使用 类名.class
线程锁
悲观锁 --独占锁
互斥锁 : 锁标记moniter 使用synchronized
排他锁 : ReentrantLock 获取锁lock() 释放锁unlock()
乐观锁 --无锁 失败重试
读写锁 : ReadWriteLock是读写锁 接口 ReentrantReadWriteLock实现了此接口 返回锁readLock() WriteLock()
获取锁lock() 释放锁unlock()
ReentrantReadWriteLock
实现Runnable接口
static ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); 定义可重入读写的锁对象, 全局唯一
上锁 lock.writeLock().lock();
操作共享资源 try{}catch(){}finally{释放锁lock.writeLock().unlock()}
可重入锁: synchronized ReentrantLock(ReentrantReadWriteLock)
当一个线程执行一个方法(此方法在循环里)时, 申请锁 分配锁 , 当执行完一次,下次执行时不需要再次申请分配,,
-.-. 一个线程执行锁方法里的锁方法 执行完美的时候分配到锁对象
当执行里面的时候不是可重入锁, 就会重新申请分配方法 而此线程已经有锁对象了 此线程会一直等待永远不会获得到的锁
> Annotation
java 自带注解 @Override Spring中的注解(ssm Maven项目)
@Target @Retention @Inherited
自定义注解 @Interface
属性 String value() default "lvjing";
注解的使用 属性的调用
> Reflection
Class
获取字节码对象
Class c = Class.forName("classPath")
类名.class
对象.getClass()
调用构造方法
c.getConstructor(int.class)
c.getDeclaredConstructor(String.class)
c.getConstructors()
c.getDeclaredConstructors()
反射新建实例
Object obj = c.newInstance();
c.getConstructor(int.class).newInstance(123);
c.getDeclaredConstructor(String.class);
con.setAccessible(true);
con.newInstance("ljving");
调用成员变量 注意: 设置获取需要指定对象 f.set(obj,"ljving")
c.getField("age") c.getFields()
c.getDeclaredField("name") c.getDeclaredFields()
Field f = c.getDeclaredField("name"); f.setAccessible(true);
f.set(obj,"ljving") f.get(obj)
调用方法 注意: 调用方法需要指定对象
c.getMethod(int.class) c.getMethods() c.getDeclaredMethods()
c.getDeclaredMethod(String.class); m.setAccessible(true);
m.invoke(obj,"ljving")
newInstance() setAccessible(true) set(Obj,value) get(Obj) invoke(obj,args)
> new Ljving(){} 匿名内部类
成员内部类
Class L{ Class J{ m(){} } } new L(); new L().new J().m();
私有化 外部类里提供访问内部类的方法
静态static L.J.m();
局部内部类
Class L{ m(){ Class J{} new J(); } } new L().m();
匿名内部类 没有名字的局部内部类 new对象时创建类执行方法
interface Lv{ m(){} }
new Lv(){}.m();
> Socket 网络编程(套接字编程)
网络通信 Socket之间的通信
服务端 Server :
new ServerSocket(10001);
Socket accept() 侦听接收套接字
void close()
客户端 Client :
new Socket(ip,port)
void close()
获取套接字Socket中的 流
InputStream socket.getInputStream();
OutputStream socket.getOutputStream();
> 序列化
操作的是对象
对象的类 实现Serializable接口 添加版本号serialVersionUID
自动添加 Serializable calss without 'serialVersionUID'
private static final long serialVersion = -3193364654654535741L
序列化
ObjectOutputStream out = new ObjectOuputStream(new FileOuputStream("filePath")); 输出到文件
out.writeObject(对象(实现序列化接口的类));
out.close();
反序列化
ObjectInputStream in = new ObjectInputSream(new FileInputStream("filePath")); 读取文件 输入到程序
in.readObject();
in.close();
> 正则表达式
常见语法
String regex = "\\d{17}[0-9X]"; 自己定义的格式
if(inupt.matches(regex)){sout()}
> 组件
对数据和方法的简单封装
> 枚举 enum
一个类的对象是有限且固定的
例如 : 自定义注解中 @Target 的源码 ElementType枚举类
使用enum定义的枚举类默认继承了java.lang.Enum，而不是继承Object类。枚举类可以实现一个或多个接口。
枚举类的所有实例都必须放在第一行展示，不需使用new 关键字，不需显式调用构造器。自动添加public static final修饰。
使用enum定义、非抽象的枚举类默认使用final修饰，不可以被继承。
枚举类的构造器只能是私有的。
一样的 SUN为0
public enum Weekday {
SUN,MON,TUS,WED,THU,FRI,SAT
}
public enum Weekday {
MON(1),TUS(2),WED(3),THU(4),FRI(5),SAT(6),SUN(0);
private int value;
private Weekday(int value){
this.value = value;
}
}
Weekday sun = Weekday.SUN;
> @Test
测试注解 导包可以直接测试注解所在方法
> ocp原则 开闭原则 open closed principe
不能改变源码
软件实体 应该对扩展开放, 对修改关闭
> java.util.concurrent.ConcurrentHashMap 工具包,支持高并发
java语言特点 java开发环境 jdk
数据类型
类,方法,变量的命名规则
运算符 分支 循环 变量 方法 数组
访问控制符 递归 泛型
面向对象 oop
异常 Exception
设计模式
API
流 Stream
集合 Collection
线程 Thread 锁 synchronized
注解 Annotation
反射 Reflection
内部类 new Lvjing(){}.m();
套接字编程(网络编程) Socket
序列化 Serializable
组件
正则表达式
枚举
__DOS命令__
> d: dir mkdir rmdir cd java cd .. cd / exit cls
__java 语言特点__
>编译性,面向对象,开源,跨平台,分布式处理,简单性,高性能,解释性,健壮性,安全性,
__java运行__
>JDK 开发工具包
JRE 运行环境,运行时类库
JVM java虚拟机
{JDK[JVM(JRE)]}
__包 类 __
>包命名域名倒着写 cn.tedu.basic
类名驼峰命名 HelloWorld
System.out.println(); 拼接符: +
__标识符__
>1.字母,数字,下滑线,$ 2.数字不能开头
3.严格区分大小写 4.见名知意
__关键字__
>53个 保留字const(常量),goto
__数据类型__
>基本类型 引用类型
byte(-128~127) short(3万) int(21亿) long float double char(0~65535) boolean
字节
__字面值__
>int double
byte short char在范围内可直接赋值
int sum = 100; int count = 30; double average = 0;
average = (double)sum/count;
>后缀 L F D
前缀0b 0 0x \u
scope Short.MIN_VALUE Integer.MIN_VALUE
默认值,0 0.0 \u0000 false null
__输入__
>import java.util.Scanner;
String s = new Scanner(System.in).nextLine();
int x = new Scanner(System.in).nextInt();
Scanner input = new Scanner(System.in);
float f = input.nextFloat();
__a b交换值__
>利用第三个变量,先加后减,先减后加
__类型转换__
>byte-> short-> int-> long
char-> int float-> double
int-> float int-> double
long-> float long-> double
byte a = 1; int b = a; 隐式转换
long c = 2200000000; int d = (int)c; 显示转换
----------2021-01-04----------
--运算规则
1.计算结果的数据类型与最大类型一致 3/2
2.byte short char 运算时自动转换为int
byte a = 1; byte b = 2; int a+b;
3.整数运算溢出 System.out.println(300000000L*60*60*24*365);
4.浮点数不精确
5.浮点数特殊值 infinity 1.5/0 NaN 0/0.0
--运算符
+-*/ % ++ --
== !=
& | && || +(字符串连接) !
? :
= += -= *= /=
int i = 1;
int x = i++ + ++i + i-- + --i;
x == 1+3+3+1=8;
i ==1;
public class Test1{
static boolean b;
public static void main(String[] args){
if(!b){
System.out.println(1);
}
}
}
--分支结构
if(){} if(){}else{} if(){}else if(){}
使用if else if 规划好条件范围
switch(a){
case 1 :
2;
break;
default : 3;
}
switch 只支持byte short int char String数据类型
----------2021-01-05----------
--循环结构
for(::){}
for(::){for(;;){}}
while(){}
do{}while();
for循环 主要的是找到需要做的与行数之间的关系(规律)
for循环是如何执行的
for嵌套循环 外层循环控制行数 内层循环控制列数(一行有多少)
--break continue
break 退出当前循环,执行下一步
continue 退出本轮循环,进入下一轮
--随机数
import java.util.Random;
int rand = new Random().nextInt(100);[0,100)
Random r = new Random();
int rand = r.nextInt(100);
double d = Math.random();[0,1)
--变量
成员变量 类里方法外,可以不用初始化,存在默认值
局部变量 方法里,必须初始化
就近原则(局部变量与成员变量同名时,优先使用局部变量)
--static
main方法中使用成员变量,方法 修饰符必须加static
public class Test1{
static int a;
public static void main(String[] args){
System.out.println(a);
method();
}
public static void method(){
System.out.println(123);
}
}
----------2021-01-06----------
--方法
public void method(){}
修饰符 访问权限
返回值看情况而定 方法返回值的位置是数据的类型
参数可有可无 形参要和实参匹配
--方法重载 overload
--重载与返回值类型无关
--重载是什么
在同一个类里,同一个方法使用不同的情况,方法名相同,但参数列表不同的现象
重载好处--体现程序的灵活性,复用性
public class Test1{
public static void main(String[] args){
method();
method(123456);
}
public static void method(){
System.out.println(123);
}
public static void method(int n){
System.out.println(n);
}
}
--数组 Array [] 下标
动态初始化
数据类型[] 数组名 = new 数据类型[数组容量];
int[] input = new int[5];
静态初始化
int[] input = new int[]{1,2,3,4};
int[] input = {1,2,3,4};
赋值
input[0]=100;
变量input是引用类型
--数组内存
1.在内存中开辟空间,存放数据,长度为数组长度
2.给每个空间赋予默认值--初始化
3.把默认值修改成你设置的值--显示初始化
4.给数组分配一个唯一地址值
5.在内存中开辟空间存放引用类型的数组变量
6.把数组地址值交给引用类型的数组变量保存
--数组访问不存在的下标
出现 数组下标超出界限异常
java.util.ArrayIndexOutOfBoundsException
--数组变量存储的是数组的地址值
[I@64616ca2 [数组 I数据类型
--遍历数组
for(int i=0;i<in.length;i++){
in[i]=i;
}
int[] n = {1,2,3,4};
for(int m:n){System.out.println(m+" ");}
----------2021.01.07----------
--数组工具类Arrays
import java.util.Arrays;
String str = Arrays.toString(array);
Arrays.sort(array);无返回值
int[] newarrays = Arrays.copyOf(int[] original,newlength);
sort 没有返回值 原数组长度没变
copyOf有返回值 原数组长度不能变,影响了长度,新数组长度
数组一旦创建,长度不可变,数据元素可变,
--toString 将数组中的数据用逗号连接成一个字符串
--sort 对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。
对引用类型数组，使用优化后的合并排序算法。
--copyOf 把数组复制成一个指定长度的新数组。
新数组长度大于原数组，相当于复制，并增加位置。--数组的扩容
新数组长度小于原数组，相当于截取前一部分数据。--数组的缩容
--面向对象--OOP(Object Oriented Programming)
Object目标,对象
Oriented以....为方向的
Programming编程
面向对象基于面向过程的
万物皆对象
--什么是面向对象?特征 封装性,继承性,多态
思想,解决什么问题
强调结果
--对象特征
封装性private 把数据封装成类组件
继承性extends 子类继承父类
多态
--对象特点
对象状态 描述对象的基本特征,属性
对象行为 描述对象的功能,方法
对象标识 唯一的地址值
--类是java语言的基本单位
在类中定义成员变量(属性),方法
在新的类中main方法,创建对象使用对象的属性方法
public class Test1{
public static void main(String[] args){
Person p = new Person();
p.per{};
}
}
class Person{
int a;
public void per(){}
}
--java内存
-方法区 类信息,常量,静态变量,编译后代码
-虚拟机栈 java方法 局部变量,操作数栈,动态链接,方法出口
-本地方法栈 Native方法
-堆 对象实例 数组
-程序计数器 字节码指令的地址或Underfined
--单一对象内存管理图
1.在栈内存中开辟空间存放引用类型的局部变量
2.在堆内存中开辟空间存放对象,
3.对象初始化
4.给对象分配唯一的地址值
5.把地址值给引用类型的局部变量保存
--多对象内存图
每次new新的对象
都会在堆内存中开辟新的空间存放新的对象
在栈内存中开辟新的空间存放局部变量
定义对象
使用方法,成员变量
封装
重用性,安全性 间接访问
被封装的属性,方法可以在本类中使用
public class Test1{
public static void main(String[] args){
Lvjing l = new Lvjing();
l.LV();
l.setName("zhaoqing");
System.out.println(l.getName());
System.out.println(l.age);
}
}
class Lvjing{
private String name;
int age;
public void lv(){
jing();
System.out.println(123);
}
private public void jing(){
System.out.println(456);
}
public void setName(String name){
this.name = name;
}
public String getName(){
renturn name;
}
}
l的值
cn.tedu.oop.Lvjing@39ed3c8d 对象地址
.java文件可以存在多个类
类 只能有一个被public修饰
.java文件的名要和public修饰的类名相同
----------2021.01.08----------
--构造方法 constructor
实例化new 含参构造
方便灵活使用对象
-构造方法一般是默认存在隐藏的,无参构造
-当类中存在有参构造时,无参构造必须写
构造方法和private资源一样,不能被子类继承,但能调用,且默认调用
-构造方法名与所在类类同名
-返回值类型为同名类类型
提供重载的构造方法--方便灵活的new
public class Test1{
public static void main(String[] args){
Lvjing l = new Lvjing();
Lvjing l = new Lvjing(1);
}
}
class Lvjing{
public Lvjing(){
System.out.println(123);
}
public Lvjing(int a){
System.out.println(a);
}
}
--构造代码块
构造方法中共性代码(成员位置)
在new对象时,优先执行构造代码块
public class Test1{
public static void main(String[] args){
Lvjing l = new Lvjing();
l.Lv();
}
}
class Lvjing{
{
int a = 1;
}
public void vjing(){
System.out.println(a);
System.out.println(123);
}
public void Lv(){
System.out.println(a);
System.out.println(456);
}
public void jing(){
System.out.println(a);
System.out.println(789);
}
}
--局部代码块 方法里
控制变量的使用范围
public class Test1{
public static void main(String[] args){
Lvjing l = new Lvjing();
l.vjing();
}
}
class Lvjing{
public void vjing(){
{
int a = 2;
{
int b = 1;
}
}
}
}
--this 特指
两种情况
必须放在构造函数第一行
1.当局部变量与成员变量同名时
2.构造方法间的调用 放在第一行
public class Test3_This {
public static void main(String[] args) {
}
}
class Person3{
String name;
int a = 20;
public Person(){
this(5);
}
public Person(int a){
System.out.println(a);
}
public void show(String name) {
this.name = name;
}
}
--访问控制符
public 公共的
protected 包裹,受保护的
default 默认 本类中本包中(但不会写出来)
private 私有的(本类中 封装)
--继承
1.以已存在的类的定义为基础创建新的类,新的的类可以增加新的数据或修改功能,不能选择性的继承 父类/超类/基类
2.提高复用性
3.java只支持单继承
4.继承具有传递性
5.继承是一种强制的依赖关系(强耦合),不推荐
6.不能继承父类的私有成员
class n extends m{}
子类继承父类
class Test{
public static void main(String[] args){
Lvjing l = new Lvjing();
l.setName("zhaoqing");
System.out.println(l.getName());
l.striking();
new Lvjing();
Lvjing l2 = new Lvjing(23);
System.out.println(l2.age);
}
}
class Lvjing{
private String name;
int age;
{
int x = 10;
}
public Lvjing(){
this(30);
System.out.println(x);
}
public Lvjing(int age){
this.age = age;
}
private public void striking(){
{
int a = 1;
{
int b = 2;
}
}
System.out.println("striking");
System.out.println(x);
}
public void setName(String name){
this.name = name;
}
pubilc String getName(){
return name;
}
public void striking_z(){
striking();
}
}
class Lvjing_gril extends Lvjing{
}
----------2021.01.11----------
char[] c ={'v','b'}
System.out.println(c);
可以打印c 打印println对char数组进行处理 遍历了char数组
--构造代码块与局部代码块
作用,触发时间节点,执行顺序
顺序-new(构造代码块(*最优先执行*)->构造方法)
-调用方法时(局部代码块在方法中(*顺序执行*))
--super
-子类使用父类中的属性,方法
this和super不可能出现在一起
构造方法中放在第一行
super相当于父类的一个引用对象
成员变量 super.name
成员方法 super.eat();
构造方法 super();默认存在 无参构造不存在,找含参构造
-*this super 区别
1.this特指所在类的属性,方法 super子类继承父类
2.this用于区分局部变量和成员变量
super用于区分本类变量和父类变量
3.this有两种情况(变量名相同,构造方法间的调用)
super有三种情况(成员变量,成员方法,构造方法)
--重写override
-概念
子类继承父类 继承所有功能,增加,修改 修改就是重写
发生在子类中
-要求
1.要有足够的权限重写,子类要重写的方法权限要比父类大
2.在子类中的方法签名/声明(-void show(int a)-) 必须 和父类 一样
-父类public void show(int a){}
-子类 void show(int a){}
-改的是方法体
3.父类中的私有方法不能被重写
4.new时 先执行父类的无参构造,再执行子类的无参构造
5.@Override重写标志,可以检查
class Fu{
public void eat(){
System.out.println("123");
}
}
class Zi extends Fu{
@Override
public void eat(){
System.out.println("456");
}
}
-*overload override 区别
overload本类方法名相同参数列表不同 override子父类方法声明相同
--static
-特点
1.静态只能调用静态,非静态调用随意
2.修饰成员变量,方法
3.跟随类的加载而加载
4.只加载一次,全局唯一,全局共享
5.多种调用方式 对象 类名
6.不能和this super同时使用,static优先加载
7.静态资源被多个对象共享
main(){
Fu f = new Fu();
f.eat();
Fu.eat();
Demo d2 = new Demo();
Demo d3 = new Demo();
d2.age=20;
System.out.println(d3.age);
Fu.name = "lvjing";//静态资源已经加载,这里只是调用赋值,
//-----------------//使用这种方法改变值之后会把对象类中的值彻底改变
System.out.println(new Demo().name);
}
class Fu{
int age;
static String name;
public Static void eat(){
System.out.println(name);
}
public void sleep(){
System.out.println(age);
System.out.println(name);
this.eat();
}
}
--静态代码块
static{}
静态代码块随着类的加载而加载,只加载一次
1.执行顺序
静态代码块-> 构造代码块-> 局部代码块
2.触发节点
静态代码块 类加载时
构造代码块 new/实例化时
局部代码块 调用所在方法时
3.作用
静态代码块 成员位置 完成项目的初始化
构造代码块 成员位置 提取类中方法的共性
局部代码块 局部位置 控制变量的范围
--final
子类继承父类,final修饰后子类只能继承不能修改
类 --被final修饰的类不能被继承
方法 --父类中final方法,子类只能继承不能override
变量 --被final修饰的变量是个常量
--public static final String name= "lvjing";
--------------------------------------------------
* super
* 在子类中使用,父类的功能
* 子类继承父类,是父类的一个引用对象,
* 构造方法中隐藏在第一行
*
* 成员变量 super.age; 位置哪一行都行
* 成员方法 super.eat(); 位置哪一行都行
* 构造方法 super(); 位置在第一行无参构造被隐藏
* 没有无参构造,必须写含参构造
* super this不能同时存在
* 不能被继承的情况
* private 构造方法 final类
*
* override
* 子类继承父类 重写的方法 子类权限要比父类大
* 声明要一样
* 标志@Override 注解 有这个标志就是重写的
* 标志作用1.检查方法是否是重写
* 2.标记
*
*
* static
* 1.随着类的加载而加载
* 2.静态只能调用静态,非静态可以随意调用
* 3.多种调用方式 对象 类名
* 4.不能和this super同时使用,static加载时对象还没加载
* 5.变量 ,方法
* 6.加载一次,一直存在,全局唯一 全局共享(多个对象使用,一个对象进行操作,其他对象也能使用)
* 7.静态方法能被继承,不能被重写
*
* static{}
* 位置成员位置,完成初始化(准备工作)
*
* Class.forName("cn.tedu.oop.Demo2");//只加载类
*
* ssm三大框架
* 准备工作,只需要加载一次,,,使用static
*
* final
* 子类只能继承不能修改
* 属性的值 常量 public static final int AGE = 10;
* final int AGE = 10; 常量名大写
* 方法 能继承不能重写
* 类 不能被继承
*/
--------------------------------------------------
----------2021.01.12----------
--多态
*****多态实现前提 继承关系+方法的重写
一个对象多种形态
灵活性,通用性
-*作用 : 统一调用标准 规则 共性 标准化
1.创建多态对象:父类引用 指向 子类对象
Lvj l = new Lji();
2.使用多态对象:-*********编译看左边,运行看右边*-
--编译看左边,多态对象,只能调用父类提供的功能
-子类扩展的方法不能用
--运行看右边 结果看子类
-如果发生重写,则结果为子类结果
方法看父类,结果看子类
-多态使用
1.成员变量 --用的是父类的,只能用父类有的
2.成员方法 --调用的父类的方法声明,执行子类的方法体
3.静态资源 --变量 使用父类的值
--方法 不能被重写,用的使父类的方法体,没有多态
4.多态对象 --只支持调用父类提供的功能 --统一标准
--方法重写,执行子类的方法体
--static final修饰的方法可以继承,不能重写
5.使用子类扩展的 --重新创建子类对象
多态好处 --不关心子类的类型,统一看做父类,屏蔽了子类之间的不同
--提高了程序的灵活性,扩展性,通用性
//让小动物吃,参数Animal是父类,不关心具体的子类类型
//不写死具体是Dog / Cat / Tiger....
public void eat(Animal a){
a.eat();
}
Animal a = new Dog();
调用父类的功能
******使用的功能只有父类有的,子类自己扩展的不能用
--异常
异常不是错误,用户使用的与程序需要的定义的不同产生的异常
父类Exception 子类很多 记三四个
//1.5 int java.util.InputMismatchException 输入类型不匹配
//3/0 java.lang.ArithmeticException by zero 算数运算异常
// java.util.ArrayIndexOutOfBoundsException 数组越界
Throwable - 顶级父类
-- Error：系统错误，无法修复
-- Exception：可修复的错误
--RunTimeException
--ClassCastException
--ClassNotFoundException
处理异常 ,
1.捕获异常 自己解决
try{
有问题代码
}catch(异常类型1 异常名字){
给出方案1
}catch(异常类型2 异常名字){
给出方案2
}catch(异常类型3 异常名字){
给出方案3
}catch(异常类型4 异常名字){
给出方案4
}
2.抛出异常 交给别人解决
public vois eat() throws 异常类型1,异常类型2{......}
--抽象类
父类方法定义的方法体,子类重写了父类的方法的方法体没有用
形成无方法体的抽象方法
public abstract void method();
-特点
1.abstract修饰 可以修饰方法,类
2.存在抽象方法的类是抽象类,抽象类可以没有抽象方法,
3.子类继承抽象类,
-*如果父类中有抽象方法,(1)子类是抽象类(2)子类重写父类所有抽象方法
-*如果父类是抽象类无抽象方法,子类可以直接继承
4.抽象类不能被实例化(new)
5.抽象类多用于多态中,父类提供方法,子类定义方法体无需abstract修饰
-使用
1.抽象类里可以有变量,常量
2.构造方法,由于父类抽象不能new,创建构造方法是为了子类使用
3.成员方法 不用重写就能继承
----------2021.01.13----------
--向上转型,向下转型
-向上转型
Fu f = new Zi();
-向下转型
使用子类的功能,父类转换为子类类型
Fu f = new Zi();
Zi z = (Zi)f;
--接口
突破java单继承的局限性
接口是程序设计的结果,用来修饰父类那一层,优化抽象层
好处提高下程序的复用性,扩展性,灵活性,
-特点
1.interface implements
2.接口中全是抽象方法,接口是一个特殊的抽象类
3.接口之间多继承,不需要重写抽象方法,实现类与接口多实现,实现类与接口继承时可以实现
4.实现类,--重写所有抽象方法 --实现类为抽象类
5.突破java单继承局限
6.面向接口开发,是一种规范
7.接口中没有变量,有常量(隐藏final static),可以使用类名调用
8.接口中没有构造方法,没有成员方法,
9.接口中抽象方法可以简写 void method();
10.接口中的资源都是public
11.实现类重写抽象方法要有足够的权限
public class Test{
public static void main(String[] args){
}
}
interface Animal{
public static final int i = 1;
abstract void method();
void method();
}
interface Animal2{
void method2();
}
interface Animal3 extends Animal,Animal2{
void method3();
}
class Cat implements Animal{
@Override
public void method(){System.out.prinfln("method");}
@Override
public void method2(){System.out.prinfln("method2");}
@Override
public void method3(){System.out.prinfln("method3");}
}
abstract class Cat2 implements Animal2{}
abstract class Animal4{}
abstract class Cat3 extends Animal4 implements Animal,Aniaml2{}
--API --Object
类Object 是类层次结构的根类,每个类都是用Object作为超类,所有对象都实现这个类的方法
java.lang不需要导包 language
每个类都是Object的子类 extends Object隐藏了
-*toString
String toString() 返回此对象的字符串 地址值
Object obj = new Object();
System.out.println(obj); 输出地址值
不需要地址值,需要属性值 --对toString()进行重写
public class Test{
public static void main(String[] args){
Student s = new Student("lvjing",23);
System.out.println(s.toString());
}
}
class Student{ --extends Object 隐藏的
private int age ;
private String name ;
public Student(){}
public Student(int age,String name){ --利用构造方法初始化,自动生成
super();
this.name = name;
this.age = age;
}
@Override
public String toString(){
return name+age;
}
}
-*equals
boolean equals(Object obj);
比较某一对象与此对象是否一致,
Student s = new Student();
Object obj = new Object();
System.out.println(s.equals(obj));--比较的是地址值是否一致
不需要比较地址值,要的是比较对象中的属性值是否一致
public class Test{
public static void main(String[] args){
Student s = new Student("lvjing",23);
Student s2 = new Student("lvjing",23);
System.out.println(s.equals(s2));
}
}
class Student{
private int age ;
private String name ;
public Student(){}
public Student(int age,String name){
super();
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object obj){
Student s = (Student)obj;
if(this.name == s.name && this.age == s.age){
return true;
}
return false;
}
}
-*hashCode
int hashCode();
返回该对象的哈希码值。
哈希码值运算得到地址值 对象在内存中的符号
Object obj = new Object();
System.out.println(obj.hashCode());
----------2021.01.14----------
String----------------------------
java.lang.String
字符串, " "
本质 是一个char类型的数组
字符串是个常量
final类不能被继承
public final class String{
public final char value[];
}
public String(char[] value)
//String 构造方法, 引用类型变量的值为字符串
char[] c = {'j','h','g','f','d','s','a'};
String str = new String(c);
System.out.println(str);
charAt char charAt(int index)
返回索引处的值
concat String concat(string str)
将指定字符串连接到当前字符的末尾
contains boolean contains(CharSequence s)
包含 此字符是否包含在字符串中,true false
endsWith boolean endsWith(String suffix)
判断是否以这个字符结束
equals boolean equals(Object anObject)
将此字符串与指定对象比较
getBytes Byte[] getBytes()
将此字符串以byte数组返回
hashCode int hashCode()
哈希码值
indexOf int indexOf(String str)
返回此字符在字符串中首次出现的位置
lastindexOf int lastindexOf(String str)
返回此字符在字符串中最后出现的位置
isEmpty boolean isEmpty()
判断字符串是否为空,空为true
length
replace String replace(char oldChar,char newChar)
用新的字符替换旧的
split String[] split(String regex)
截取此字符,返回其他字符,截取位置为空
startsWith boolean startsWith(String prefix)
substring(int i) String substring(int beginIndex)
截取子串,从索引2到结束
substring(int i,int x) String substring(int beginIndex,int endIndex)
截取子串,从索引[2,6),索引含头不含尾
toCharArray char[] toCharArray()
将字符串转换为新的字符数组
toLowerCase String toLowerCase()
全小写
toUpperCase String UpperCase()
全小写
trim String trim()
去掉字符串头尾空白
String sss = " 123456 ";
System.out.println(sss);
System.out.println(sss.trim());
valueOf static String valueOf(int i)
将参数返回为字符串类型
StringBuilder---------------------------------
* 优化字符串拼接 +
* StringBuilder()
* StringBuilder append(String str)
*
* StringBuffer
*
*
* 计时
* long start = System.currentTimeMillis();
* long end = System.currentTimeMillis();
* 放在需要计时的地方
*
*
*
* String 用 + 拼接
* String常量不能改,每次拼接需要开辟新的空间进行运算
*
* append拼接
* 改变自身的值,不需要开辟空间,时间少
StringBuilder s = new StringBuilder();
StringBuffer s1 = new StringBuffer();
String a = "123456";
long start = System.currentTimeMillis();
for(int i = 1;i<=100;i++) {
s1 = s1.append(a);
}
long end = System.currentTimeMillis();
System.out.println(end-start);
包装类---------------------------------
* 基本类型方法
*
* Number----------
* 提取了数字包装类共性 把包装类转换为基本类型
*
* Integer-
* Integer(int value) 自动装箱 int->Integer
*
* intValue 自动拆箱 Integer->int
* int intValue()
* 以int类型返回Integer值
*
* parseInt
* static int parseInt(String s)
* 把字符串类型的整数转成int类型
*
* valueOf
* static Integer valueOf(int i)
* 返回一个表示指定的 int 值的 Integer 实例
Integer inte = new Integer(10);
Integer fs = Integer.valueOf(123);
System.out.println(fs.intValue()+1);
System.out.println(Integer.parseInt("123456")+123);
Date-----------------------------------------
* Date()
* 分配 Date 对象并初始化此对象，
* 以表示分配它的时间（精确到毫秒）。
* 创建对象会初始化为系统日期
* getHours()
* getMinutes()
* getSeconds()
*
* getYear() 从1970.1.1到现在的多少年
* getMonth() 0 表示January
* getDate()
* getDay()
*
* getTime() 从1970.1.1到现在的毫秒值
simpleDateFormat----------------------------
* 两种类型的日期类型互转
* String<-->Date
*
* SimpleDateFormat(String pattern)
* 将yyyy-MM-dd转换为Date "yyyy.MM.dd"
*
* date->String String format(Date date)
* String->date Date parse(String test)
--------------------------------------------
BigDeciml 解决小数运算不精确
BigInteger 超大整数运算
*
* BigDeciml
* BigDeciml(Double val) 不精确
* BigDeciml(String val) 精确 构造字符串类型的含参构造
*
* add
* subtract
* multiply
* divide
//divide(x,y,z)
//x 要参与的对象
//y 保留位数
//z 舍入方法 ROUND_HELF_UP
BigDecimal div_r2 = dec1.divide(dec2,5,BigDecimal.ROUND_HALF_UP);
----------2021.01.15----------
IO-------
读取写出 相对程序而言 --程序读取in磁盘 程序写出out磁盘
字符流 字符,txt
字节流 图片,音频 所有文件
流 单向流动
File-----------------------
java.io 包
File文件流
File(String pathname)
把指定位置的文件加载到程序中
File f = new File("D:\\iotest\\io.txt");
length() long length() 文件的字节量
exists() boolean exists() 文件是否存在，存在返回true
isFile() boolean isFile() 是否为文件，是文件返回true
isDirectory() boolean isDirectory() 是否为文件夹，是文件夹返回true
getName() String getName() 获取文件/文件夹名
getParent() String getParent() 获取父文件夹的路径
getAbsolutePath() String getAbsolutePath() 获取文件的完整路径
createNewFile() boolean createNewFile() 新建文件，文件夹不存在会异常，文件已经存在返回false
mkdirs() boolean mkdirs() 新建多层不存在的文件夹\a\b\c
mkdir() boolean mkdir() 新建单层不存在的文件夹\a
delete() boolean delete() 删除文件，删除空文件夹
list() String[] list() Arrays.toString(f5.list()) 返回String[]，包含文件名
listFiles() File[] listFiles() Arrays.toString(f5.listFiles()) 返回File[]，包含文件对象
读取流---------------------
读取磁盘中的数据 读取到程序中
1.字符流读取:只能读txt数据
2.字节流读取:所有数据
*字节流读取
InputStream
FileInputStream
BufferedInputStream
InputStream 读取流的父类 抽象类 共性
void close() 关闭此输入流并释放与该流关联的所有系统资源。
abstract int read() 从输入流中读取数据的下一个字节。
int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
int read(byte[] b,int off,int len)
FileInputStream 子类
从文件系统中的某个文件中获得输入字节
FileInputStream(File file) 参数为File对象
FileInputStream(String name) 参数为文件所在路径
BufferedInputStream
BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in, int size)
1.FileInputStream与BufferedInputStream区别
文件中的数据一个一个读 操作系统读取
BufferedInputStream底层维护了一个byte[]buf 数组默认容量8192
使用了byte数组,一次读一个数组8192字节
2.效率
BufferedInputStream > FileInputStream
创建对象,含参构造,参数为父类(父类不能对象,多态,new任何子类)
InputStream b = new BufferedInputStream(new FileInputStream("D:\\iotest\\2\\1.txt"));
写出流-----------------------------------
程序中的数据写出到磁盘中
字符写出流
字节写出流
**字节写出流
OutputStream 抽象
FileOutputStream
BufferOutputStream
OutputStream 父类 抽象类 共性方法
void close() 关闭此输出流并释放与此流有关的所有系统资源。
void flush() 刷新此输出流并强制写出所有缓冲的输出字节。
void write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。
void write(byte[] b, int off, int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
abstract void write(int b)将指定的字节写入此输出流。
FileOutputStream
FileOutputStream(String name)
创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(String name, boolean append)
创建一个向具有指定 name 的文件中写入数据的输出文件流。
BufferOutputStream
BufferOutputStream(OutputStream out)
FileOutputStream和BufferOutputStream区别
FileOutputStream > BufferOutputStream
BufferOutputStream底层维护了一个byte[] b
创建对象,含参构造,参数为父类(父类不能对象,多态,new任何子类)
InputStream b = new BufferedInputStream(new FileInputStream("D:\\iotest\\1.txt"));
----------2021.01.18----------
--read/write close
在IO流中close关闭资源后,再read/write会出想异常,
关闭之后流(对象)就会被释放,所以异常
--递归
在方法中使用方法本身,减少代码的书写,但是占用内存
main(){
File f = new File("D:\\123\\123")
long size = sizeOf(f);
}
sizeOf(File s){
File[] f_s = s.listFiles();
long sum = 0;
for(int i = 0; i<f_s.length;i++){
if(f_s[i].isfile){
sum += f_s[i].length();
}else{
sum += sizeOf(f_s[i]);
}
}
}
--删除文件
不空的文件夹,需要
1.列出文件夹里的所有资源
遍历数组,得到每个资源a[i]
2.判断资源是文件就删除
3.判断资源是文件夹的话 重复123
遍历文件夹 文件删除,不是空的文件夹递归del() del之后文件为空 file.delete()
main(){
System.out.println("请输入文件路径: ");
String s_in = new Scanner(System.in).nextLine();
File f = new File(s_in);
System.out.println(del(f));
}
public static boolean del(File file){
File[] f = file.listFiles();
//如果不是空的
boolean b = false;
for (int i = 0;i<f.length;i++){
//是不是文件,,直接删除
if (f[i].isFile()){
b = f[i].delete();
}else{
//是文件夹,不为空,递归
del(f[i]);
}
}
//空文件夹
b = file.delete();
return b;
}
--泛型
List<E>
Generic <> 配合集合一起用 程序增强器 出现错误显示在编译期
用来约束集合中的元素的类型
用法:
类/接口 class Student<String>{} 约束类里元素类型
方法 public <Student> void eat(Student s){}
<>中的字母 E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
? - 表示不确定的java类型
好处: 检查集合中的元素,在编译时报错
List <String>list = new ArrayList();
<>中间为引用类型 包装类(基本类型) 用来约束类型
list.add(100); ()里使用的是100基本类型
在这里使用的包装类的 装箱 int->Integer
--集合
和数组一样可以存储多个数据
优缺点: 数组 下标查的快 长度不可变,数据类型必须统一
集合 长度可变,数据类型丰富,
Collection(接口) 与子接口关系extends
List(接口) 与实现类关系implements
ArrayList(实现类)
LinkedList(实现类)
Set(接口) 与实现类关系implements
HashSet(实现类)
TreeSet(实现类)
共性方法,学习抽象层
创建对象,学习实现类
--Collection
Collection 层次结构 中的根接口。
Collection 表示一组对象，
这些对象也称为 collection 的元素。
add boolean add(E e) 添加
clear void clear() 清除
contains boolean contains(Object o) 包含
equals boolean equals(Object o) 相等
hashCode int hashCode() 哈希码值
isEmpty boolean isEmpty() 空true
remove boolean remove(object o) 移除元素o
size int size() 元素个数
toArray object[] toArray() 返回所有元素数组
addAll boolean addAll(collection<?> c) 集合c添加到此集合中
containsAll boolean containsAll(collection<?> c) 此集合是否包含集合c
removeAll boolean removeAll(collection<?> c) 移除此集合与集合c的交集
retainAll boolean retainAll(collection<?> c) 保留此集合与集合c的交集
--Iterator<E> iterator() 获取集合中的元素
迭代集合中的元素 返回可以迭代集合元素的迭代器
boolean hasNext() 如果仍有元素可以迭代，则返回 true。
E next() 返回迭代的下一个元素。
void remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。
Collection<Integer> col3 = new ArrayList();
col3.add(1); col3.add(12); col3.add(13);
Iterator<Integer> it = col3.iterator();
System.out.println(it);
while (it.hasNext()){//判断,有元素返回true
Integer date = it.next();
System.out.println(date);
}
--foreach
//for(遍历得到的数据类型 变量名:要遍历的容器){}
//foreach/增强for循环 --场景:数组/Collection集合
for (Integer co:col3){
System.out.println(co);
}
--List
特点: 有序 有索引 允许重复 可以多个null
方法:
add void add(int index,E element) 在索引index处添加元素element
get E get(int index) 返回索引为index的元素
indexOf int indexOf(Object o) 元素o在集合中首次出现的索引值
lastIndexOf int lastIndexOf(Object o) 元素o在集合中最后一次出现的索引值
remove E remove(int index) 移除下标为index的值
remove boolean remove(Object o) 移除第一次出现的指定元素
set E set(int index,E element) 替换下标为index,替换为e
subList List<E> subList(int fromIndex, int toIndex)
截取索引f到to的值 [int,int)
boolean addAll(int index,Collection c)
--listIterator<E> listIterator()
List集合的迭代方式
方式1: 继承自Collection的iterator()*****************
Iterator<String> it = l2.iterator();//父接口 返回值
while (it.hasNext()){System.out.println(it.next()); }
//方式2: ListIterator<E> listIterator()****************
ListIterator<String> it2 = l2.listIterator();//扩展的 返回值
//使用父接口的功能 ---顺序向后迭代
// while (it2.hasNext()){
// System.out.println(it2.next());
// }
//使用子接口扩展功能 --逆向迭代
while (it2.hasPrevious()){
System.out.println(it2.previous());
}
/*
方式1和方式2区别
来源: iterator():父接口 listIterator():自己扩展的
返回: 父接口 顺序迭代 子接口 逆向迭代
子接口使用父接口的所有功能,也可以扩展(顺序迭代,逆向迭代)
*/
//方式3: 用下标遍历
for(int i = 0;i<l2.size();i++){
System.out.println(l2.get(i));
}
//方式4: foreach
for (String co:l2){
System.out.println(co);
}
--ArrayList
实现了list接口,拥有list接口的所有特点和方法
*****底层维护了一个可变大小的数组,存数据
ArrayList() length为10的空列表
new时,底层维护了一个Object[],叫elementDate
初始容量为空,,jdk1.8 当开始add()才开始扩容
jdk1.6只要new就分配10个容量
当add()时,会拿到数据之后,直接存入数组中
elementDate[size++] = 1;
数组的默认容量是10 ,超过10时,会自动扩容,以前的1.5倍
//模拟ArrayList
//1.本质是数组存数据
Object[] ab = new Object[10];//存的数据丰富
//2.往数组里存数据
ab[0]=10;
ab[1]=1.2;
ab[2]="123";
ab[3]='晶';
ab[4]=true;
ab[5]=10;
if (size>10){
自动扩容, ---新的数组容量是原来的1.5倍
Arrays.copyOf(a,15);
}
----------2021.01.19----------
l.remove(5)
l.remove(new Integer(100))
l.remove((Object)100)
--LinkedList
LinkedList() 构造空列表
实现类,可以使用Collection和list所有功能,也可以扩展
底层是一个链表结构,扩展了对链表首尾元素的操作
addFirst void addFirst(E e)在链表开头添加元素
addLast void addLast(E e)在链表结尾添加元素
getFirst E getFirst()获取链表开头元素
getLast E getLast()获取链表结尾元素
removeFirst E removeFirst()移除链表开头元素
removeLast E removeLast()移除链表结尾元素
offerFirst 添加
offerLast
peekFirst 获取
peekLast
pollFirst 移除
pollLast
------ArrayList和LinkedList区别
都继承自List,具有List的所有功能
ArrayList底层是数组 连续的空间 查询快
LinkedList底层是链表 不连续的空间 增删快
ArrayList查询快数组的查询
LinkedList增删是改变该元素相邻的两个元素的指向,
--Set
无序的 不能重复 存一个null 没有索引
用来给数据去重
set.add("1230"); set的底层源码
map.put("1230",new Object());
--HashSet
HashSet HashSet()构造一个新的空Set
add boolean add(E e)
clear void clear()
contains boolean contains(Object o)
isEmpty boolean isEmpty()
remove boolean remove(Object o)
size long size()
创建对象 --底层创建了HashMap对象
Set<Integer> s = new HashSet();
s.add(1); add数据 本质 上拿着数据存入map里
迭代Set集合
继承Collection Iterator<E> iterator
foreach
Iterator i = s.iterator();
while (i.hasNext()){
System.out.print(i.next()+" ");
}
System.out.println();
for (Integer x : s){
System.out.print(x+" ");
}
--Map
Map<k,v> 键key 不能重复 值value 可以重复
Map里的数据一对一对出现, 键值 对
数据格式要求 list.add(100) map.put("name","12346578912")
Map集合 特点 无序 kay值唯一否则value被覆盖 null
键集 值集 键值映射关系集
put v put(K Key,V Value)
get v get(Object key)
clear void clear()
containsKey boolean containsKey(Object key)
containsValue boolean containValue(Object value)
equals boolean eauals(Object o)
hashCode int hashCode()
isEmpty boolean isEmpty()
remove V remove(Object key)
size int size()
values Collection<V> values()
entrySet Set<Map.Entry<K,V>> entrySet()
keySet Set<K> keySet()
迭代map集合
1.key 把键集存入集合set中 Set<K> keySet() get(key)
把m里的所有key存入set
Set<String> set = m.keySet();keySet
迭代set 获取每个key
for (String key : set){
Integer value = m.get(key);
System.out.println(key+":::"+value);
}
2.Collection<V> values() --把map里的value存入Collection里
把map里的value存入Collection
Collection<Integer> values = m.values();
for (Integer value:values){
System.out.println(value);
}
3.set<Map.Entry<K,V>> entrySet()
把map里的整条记录存入set集合中
Set<Map.Entry<String,Integer>> set1 = m.entrySet();
迭代set,获取每个
for(Map.Entry<String,Integer> y : set1){
String key = y.getKey();
Integer value = y.getValue();
System.out.println(key+"...."+value);
}
获取entry的key和value
-----Map.Entry<K,Y>
K getKey() 返回此项对应的键
V getValue() 返回此项对应的值
--HashMap
Map接口的实现类 底层是哈希表/散列表 的结构
对象
HashMap()
构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空
原理********************
此实现假定哈希函数将元素适当地分布在各桶之间，可为基本操作（get 和 put）提供稳定的性能。迭代 collection 视图所需的时间与 HashMap 实例的“容量”（桶的数量）及其大小（键-值映射关系数）成比例。所以，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。
HashMap 的实例有两个参数影响其性能：初始容量 和加载因子。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。
通常，默认加载因子 (.75) 在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap 类的操作中，包括 get 和 put 操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少 rehash 操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash 操作。
如果很多映射关系要存储在 HashMap 实例中，则相对于按需执行自动的 rehash 操作以增大表的容量来说，使用足够大的初始容量创建它将使得映射关系能更有效地存储。
123456**********
向HashMap中存储数据
计算hash(key)数据的存储位置,存入哪个桶里,最好合理分布到每个桶里
考虑两个影响, HashMap性能的因素:初始容量(16) + 加载因子(阈值0.75)
默认容量为16,但达到16的0.75,进行rehash操作,重建内部数据结构,哈希表将具有两倍容量
默认加载因子 (.75) 在时间和空间成本上寻求一种折衷。
加载因子过高虽然减少了空间开销，但同时也增加了查询成本,
加载因子过低,需要频繁的rehash
---------
基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
HashMap底层是一个Entry数组，当存放数据时会根据hash算法计算数据的存放位置。算法：hash(key)%n，n就是数组的长度。
当计算的位置没有数据时，就直接存放，当计算的位置有数据时也就是发生hash冲突的时候/hash碰撞时，采用链表的方式来解决的，在对应的数组位置存放链表的头结点。对链表而言，新加入的节点会从头结点加入。
数组 链表
----------2021.01.20----------
--统计字符串中字符出现的次数
用户输入字符串,
获取每个字符 charAt
a-1,b-2 使用map存储 Map<Key,Value>
charAt获取到的字符存入 key
使用value记录次数
集合默认值为null
从集合中读取首次为null所以先判断第一次读到key
get 参数为键集 返回值集
使用get读取map中的value
第一次读到为null
不是第一次为value+1
--Collections集合
提供静态的方法 可以直接调用
static <T> boolean addAll(Collection<? super T> c, T... elements)
将所有指定元素添加到指定 collection 中。
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定比较器产生的顺序，返回给定 collection 的最大元素。
static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定比较器产生的顺序，返回给定 collection 的最小元素。
static void reverse(List<?> list)
反转指定列表中元素的顺序。
List<Integer> list = new List();
addAll(list对象,添加的值)
Collections.addAll(list, ...elements: 1,2,3,4,5);
... 三个点是可变参数
--线程
多线程,本质上提高了CPU的效率
1.进程和线程区别
进程:正在运行的程序, 特点,独立性,动态性,并发性
线程:是操作系统能够进行运算调度的最小单位,
进程包含线程,线程是进程中的实际运作单位
一个软件的运行需要依赖进程,一个进程的运行需要依赖线程
2.并发和并行区别
并发:是多个软件抢占一个CPU资源,发生了抢占现象
并行:是多个CPU,每个CPU执行一个任务,不抢
3.多线程特性
随机性 同一时刻只能有一个程序执行
线程的状态
4.线程的状态
新建状态 可运行状态(就绪状态) 运行状态 阻塞状态
运行状态进入各种阻塞状态,阻塞状态结束之后进入可运行状态,
阻塞状态,正在执行的程序被其他程序挤占,进入阻塞
--模拟多线程编程
Thread类
Runnable接口
需要执行的 写在run()方法里
--Thread
Thread() 分配新的Thread对象
Thread(Runnable target) 分配新的 Thread 对象。
currentThread static Thread currentThread() 获取当前正在执行任务的线程对象
getId long getId() Id标识符
getName String getName
setName void setName(String name)
run void run() 运行
start void start() 启动
stop void stop()
sleep static void sleep(long millis) 休眠一段时间 运行中
--打印10次线程名称
main(){
MyThread map = new MyThread();
MyThread map2 = new MyThread();
map.start();
map2.start();
}
class MyThread extends Thread{
@Override
public void run(){
for(int i = 0;i < 10;i++){
System.out.println(super.getName()+"~~"+i);
}
}
}
*****多线程随机性
Thread-0~~0
Thread-1~~0
Thread-1~~2
Thread-0~~1
*****线程的状态
新建状态 main方法中new()对象时
可运行状态 使用start()方法启动线程+执行线程的run方法
运行状态 执行run()方法具体内容处在运行状态
终止状态 run方法运行完毕
--Runnable
run void run()
实现接口implements Runnable 重写run方法
若使用getName方法获取线程名字,要使用Thread.currentThread()方法获取当前正在执行任务的线程对象(因为Runnable接口中只有run方法,)获取到的对象时Thread类型,调用getName 方法
创建实现类对象(只有run方法),要调用start启动线程,需要使用Thread(Runnable target)构造方法new对象,绑定Thread和目标类的关系
--两种多线程 对比
缺点:Runnable功能太少 Thread只能单继承,耦合性强
优点:Runnable接口松耦合,Thread提供丰富的方法
--怎么判断数据在多线程编程时,有没有安全隐患
如果有多条代码操作了共享资源,一定要加锁
----------2021.01.21----------
--同步锁
是指把共享资源加锁,实现排队的效果,不抢了
同步: 是指排队,不抢的现象
锁: 就是把共享资源加锁,保证安全
synchronized
用在方法上,加锁 synchronized public void show(){}
用在代码块上 synchronized(锁对象){可能有问题的代码}
-******看多线程程序会不会出错
Thread.sleep(5000);
--同步和异步的区别
同步:指不会发生枪占的现象,是一个排队的效果 synchronized
异步:指多个资源抢占操作共享资源
好处:
同步 保证了安全,牺牲了效率
异步 效率高,牺牲了安全
----------
--售票 四个窗口共卖100张票
1.Thread
public class Test6_Tickets {
public static void main(String[] args) {
//模拟多线程买票
MyTickets t1 = new MyTickets();
MyTickets t2 = new MyTickets();
MyTickets t3 = new MyTickets();
MyTickets t4 = new MyTickets();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class MyTickets extends Thread{
//定义变量,记录票数
static int tickets = 100;
//准备卖票,tickets--//如果有票就卖,
@Override
//synchronized public void run(){//没锁住,分配的锁对象是this
public void run(){
while(true) {
synchronized (MyTickets.class) {
if (tickets > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();//开发阶段,出错行
}
System.out.println(super.getName() + "***" + tickets--);
} else {
break;
}}}}}
问题
1.卖了400张?
原因:tickets是成员变量,new了4次,在内存中就产生了4份
解决方案:把tickets变成共享资源,只加载一次,(类加载的时候加载static)
2.重卖 一张票卖了多次
随机性,CPU执行的 那就模拟CPU怎么运行的
四个start同时进入run方法,
原因:当四个线程进入run方法,进入睡眠中sleep,四个(醒过来)先后执行有顺序,
当一个线程执行输出tickets,而CPU未执行tickets-- 使得tickets的值没变
因此当下一个start线程执行时(醒来)输出的与上一个一样.
3.多卖/超卖 卖出了不存在的票0 -1 -2
原因:当tickets为1四个线程同时进入run方法,通过if条件,sleep之后,一个接一个执行,
输出 1 0 -1 -2 会出现
2.Runnable
public class Test1_Tickets {
public static void main(String[] args) {
Tickets t = new Tickets();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Tickets implements Runnable{
int tickets = 100;
Object obj = new Object();
String s = new String();
@Override
public void run() {
while (true){
synchronized (s) {
if (tickets > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "~~" + tickets--);
} else {
break;
}}}}}
问题
不会400张,因为new tickets 只new了一次,tickets只加载了一次
重卖 多卖
--
1.同步方法(普通方法)
使用synchronized关键字实现同步锁机制 加在方法上同步方法
实现了多个线程需要排队等待的效果,牺牲了性能保证了安全
synchronized public void run() {
同步方法,在使用synchronized关键字是,会自动分配锁对象
如果共享资源是静态的,锁对象必须是 类名.class
普通方法分配的锁对象是this,静态方法分配的锁对象是 类名.class
2.同步代码块
共享资源(普通资源)
锁位置: 共享资源被第一次使用开始,用完结束
锁对象: 可以任意,必须是同一个对象 任意的,唯一的 只加载一次
使锁对象只加载一次,在同步代码块位置,一次只允许一个start通过
synchronized(锁对象){有问题的代码块}
synchronized (new Object()) {//不对,start执行run时不是同一个对象
synchronized (this) { 锁对象 使用this 使用的是本类对象
----------
/*
StringBuffer synchronized
StringBuilder
*/
/*
ReentrantReadWriteLock 读写锁 写加锁 读不加锁
*/
/*
线程创建的其他方式
线程池 获取已经准备好的线程 直接用
*/
--设计模式 23种 规则
单例模式Singleton
设计模式:是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
--Singleton
单例设计模式
保证一个类仅有一个实例,并提供一个访问它的全局访问点。
1.饿汉式 --写法简单,是常用的写法
2.懒汉式 --写法负责,是面试的重点,,按需加载+线程安全
------------------
public class Test2 {
public static void main(String[] args) {
MySingleton m1 = MySingleton.getM();
MySingleton m2 = MySingleton.getM();
System.out.println(m1);
System.out.println(m2);
// == 比较,基本类型比较的是值,引用类型比较的是地址值
System.out.println(m1==m2);
MySingleton2 m3 = MySingleton2.getM();
MySingleton2 m4 = MySingleton2.getM();
System.out.println(m3);
System.out.println(m4);
System.out.println(m3==m4);
}
}
//单例模式 --懒汉式 按需加载+线程安全
class MySingleton2{
int i = 10;
private MySingleton2(){}
private static MySingleton2 m;
//第一种:
//synchronized public static MySingleton2 getM(){
//共享资源,m是静态的,使用的锁对象必须是固定的类型.class
//直接给静态的方法加锁,锁对象为类名.class
public static MySingleton2 getM(){
//第二种:
//synchronized (MySingleton2.class) {
//锁方法,方法里的性能都低 所以不用
// if (m == null) {
// m = new MySingleton2();
// }
// return m;
//}
if (m == null) {
m = new MySingleton2();
}
return m;
}
public void me(){
System.out.println(++i);
}
}
//单例模式 --饿汉式
class MySingleton{
int i = 10;
private MySingleton(){}
private static MySingleton m = new MySingleton();
public static MySingleton getM(){
return m;
}}
1.不让外界随便new --私有化构造方法
2.在内部创建一个对象,给外界提供 ****成员变量封装
static 被静态方法getM调用,也要变成静态的, 静态只能调用静态
3.给外界提供公共的方法,返回m
static 无法通过对象的方式访问,只能使用类名调用方法,
static 可以使用类名调用方法
------------------
--注解 Annotation @
利用注解快速开发,减少代码的编写,通常,注解可以代替一部分代码
三大框架 SSM SpringMVC Spring Mybatis 微服务SpringBoot
JDK注解
@Override
@Deprecated
@SuppressWarnings
@SafeVarargs
@FunctionallInterface
元注解
配合自定义注解 描述注解的注解
@Target 注解用在哪里：类上、方法上、属性上
@Retention 注解的生命周期：源文件中、class文件中、运行中
@Inherited 允许子注解继承
@Documented 生成javadoc时会包含注解，不常用
@Repeatable 注解为可重复类型注解，可以在同一个地方多次使用，不常用
@Target 维护在ElementType.class工具类
ElementType.ANNOTATION_TYPE 应用于注释类型
ElementType.CONSTRUCTOR 应用于构造函数
ElementType.FIELD 应用于字段或属性
ElementType.LOCAL_VARIABLE 应用于局部变量
ElementType.METHOD 应用于方法级
ElementType.PACKAGE 应用于包声明
ElementType.PARAMETER 应用于方法的参数parameter
ElementType.TYPE 应用于类的元素
@Retention RetentionPolicy.class
SOURCE 在源文件中有效（即源文件保留） .java
CLASS 在class文件中有效（即class保留）
RUNTIME 在运行时有效（即运行时保留）
自定义注解
第一步:定义注解 --语法:@interface 注解名
1.注解位置
2.注解生命周期
3.给注解添加属性
// 在使用自定义注解时 设置Mapper中name属性的值 @Mapper(name="lvjing")
//给属性赋予默认值 在Mapper中 int age() default 0;
//特殊属性 value 特殊值在用时可以直接赋值
@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD,ElementType.PARAMETER})
@Retention(RetentionPolicy.SOURCE)
@interface Mapper{
String name();
int age() default 0;
String value() default "1";
}
第二步:使用注解 语法:@注解名
注解的位置必须符合,@Terget 的要求
@Mapper(name="lvjing",age = 0123,value = "123")
class Hello{
@Mapper(name = "", value = "123")
String name;
@Mapper(name = "")
public void show(@Mapper(name="lv",value = "789") int age){
System.out.println(age);
}
}
/*
注解属性
有默认值可以不用赋值 没有默认值必须赋值
同时给多个属性赋值,要写value="" value不能省略
*/
----------2021.01.22----------
--Tickets t = new Tickets();
//绑定目标类和Thread关系
Thread t1 = new Thread(t);
--Debug/断点模式
调试代码 1.设置断点 2.开启断点
Debug之后可以一步一步运行
--反射Reflection
底层JVM(jvm反射.class文件解析)用来 获取解析类里的所有数据
包括:类里的所有信息,成员变量,方法,构造方法,包括私有的
使用:Class工具类 用来解析.class文件里的数据
.**.获取到的对象 对象.方法 获取此对象的信息
Class class = new Class(); //**不能new private Class(){}
获取对象 --提供了丰富的方法来解析.Class文件的数据
Class.forName("类的全路径") static Class<?> forName(String className)
类名.class
对象.getClass() Object提供的getClass方法m
.**.获得包名、类名
clazz.getPackage().getName() Package getPackage() //包名
clazz.getSimpleName() String getSimpleName() //类名
clazz.getName() String getName() //完整类名
返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称
.**.成员变量定义信息
getFields() Field[] getFields() //所有可访问公共字段。
获得所有公开的成员变量，包括继承的变量
getDeclaredFields() //获得本类定义的成员变量，包括私有,不包括继承的变量
getField(变量名) Field getField(String name)
getDeclaredField(变量名)
.**.构造方法定义信息 构造方法自动生成 alt+insert
getConstructor(参数类型列表) Constructor<T> getConstructor(Class<?>... parameterTypes)
//获得公开的构造方法
getConstructors() Constructor<?>[] getConstructors() //获得所有公开的构造方法
getDeclaredConstructors() Constructor<?>[] getDeclaredConstructors()
//获得所有构造方法，包括私有
getDeclaredConstructor(int.class, String.class)
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
.**.方法定义信息
getMethods()//获得所有可见的方法，包括继承的方法
getMethod(方法名,参数类型列表) Method getMethod(String name, Class<?>... parameterTypes)
getDeclaredMethods()//获得本类定义的方法，包括私有,不包括继承的方法
getDeclaredMethod(方法名, int.class, String.class)
.**.反射新建实例
c.newInstance();//执行无参构造
c.newInstance(6, "abc");//执行有参构造
c.getConstructor(int.class, String.class); //执行含参构造，获取构造方法
.**.反射调用成员变量
c.getDeclaredField(变量名); //获取变量
c.setAccessible(true); //使私有成员允许访问
f.set(实例, 值); //为指定实例的变量赋值，静态变量，第一参数给 null
f.get(实例); //访问指定实例的变量的值，静态变量，第一参数给 null
.**.反射调用成员方法
Method m = c.getDeclaredMethod(方法名, 参数类型列表);
m.setAccessible(true) ;//使私有方法允许被调用
m.invoke(实例, 参数数据) ;//让指定的实例来执行该方法
Class[] cla = item.getParameterTypes();//参数类型
----------2021.01.25----------
--触发含参构造
Class c = Student.class;
Constructor con = c.getConstructor(int.class)
Object obj = con.newInstance(123);触发含参构造
System.out.println(obj)
--内部类
--匿名内部类
--网络编程
69
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
