如果内容是基本类型 传递的 是值 形参改变 实参不变
如果内容是引用类型 传递的 是引用 形参改变 实参跟着改变
1.每一个类都有构造方法，若自己在类中没有定义，系统会默认提供一个无参数的构造方法
若在类中自己定义了构造方法，则默认无参数的构造方法即被覆盖
2.构造方法是否存在方法重载?----存在构造方法重载
5.块可以在里面写一些程序 我想要在创建对象之前执行
2.this既然代替的是一个对象
this可以调用什么? 属性 方法 可以
this可以调用构造方法么? 可以 在一个构造方法内可以调用另一个构造方法
通过this(); 省略了构造方法的名字(必须与类名一致)
必须在另一个构造方法内调用 必须在程序的第一行
构造方法 一般方法 有顺序 认为构造方法早于一般方法
在一般方法内调用构造方法呢？ 不行
构造方法可以重载 构造方法 调用另一个构造方法呢?
3.this调用的过程可以放置在哪个位置写?
调用属性或方法 这一行代码 可以放置在类中的任何成员位置 上下顺序随意
2.子类继承了父类，可以调用父类中(public protected)的属性和方法
2.1构造方法严格意义来说 不算做子类继承过来
只是单纯的在子类调用构造方法时默认调用父类的构造方法
2.2程序块严格意义来说 不算做子类继承过来(子类自己调用不到 没名字)
程序块子类不能直接调用 子类执行构造方法之前
默认调用了父类的构造方法 父类构造方法之前自动执行父类的块
this和super都可以调用构造方法，只能放在另一个构造方法第一行
当利用this或super调用构造方法时，他们两个不能同时出现(他们都想抢占第一行，冲突啦)
设计类的关系遵循的原则:高内聚低耦合
耦合度: 紧密 继承(实现) > 包含 > 依赖
switch(identity){// int(byte short) char enum 1.7String
知识回顾
修饰符
权限
public protected 默认不写 private
public 公有的 当前工程的任意位置访问
protected 保护的 本类 同包 子类
默认不写 默认的 本类 同包
private 私有的 本类
封装思想---->类 方法 保护属性 私有属性+共有get/set
特征
final static abstract native (transient synchronized volatile)
final
修饰变量 只有一次赋值的机会 不能再发生改变
修饰属性 要求必须赋初始值 不能再次发生改变
修饰方法 该方法不能被子类重写(覆盖)
修饰类 该类不能被其他的子类继承
static
修饰属性 修饰方法 修饰块 修饰内部类
1.静态元素在类加载时即被初始化，创建的很早，创建时只有类，还没有对象
2.静态元素存储在静态元素区中，每一个类有一个单独的自己的区域，与别的类不冲突
3.静态元素区不能被GC管理，可以简单粗暴的认为静态元素常驻内存
4.静态元素只加载一次(只存在一份儿)，全部类对象及类本身共享
5.可以理解为静态元素与对象没有关系，属于类的
6.由于静态元素在加载的时候有可能没有创建对象，我们可以通过类名字直接访问
7.静态元素可以直接访问静态元素(都存在静态元素区中)
8.非静态元素可以直接访问静态元素(非静态–>堆内存对象空间里 静态元素—>静态区)
9.静态元素不可以访问非静态元素(静态元素是单独存在—>找寻非静态元素 有一堆一样的 说不清)
10.静态元素中不可以使用this或super关键字(静态元素可以理解为属于类 this/super代替对象)
abstract
好似借钱：可以向上借钱，可以向下借钱，有钱人借钱必须先把我的债务给还清了
interface(定义规则)
欠了一屁股的债，上面没有人可以借给他钱
静态常量的应用场景-----单例设计模式
增强程序的可读性 static final 属性=0
单例模式的实现
1.私有的构造方法
2.私有的静态的当前类对象作为属性
3.公有的静态的方法返回当前类对象
存在继承关系的类 加载机制 及执行过程
加载类的过程---静态元素已经加载
new Person();
1.加载父类
2.父类会产生自己的静态空间 属性 方法 块
执行静态块
3.加载子类
4.子类会产生自己的静态空间 属性 方法 块
执行静态块
5.开辟对象空间
6.加载父类的非静态成员 属性 方法 块 构造方法
7. 执行块 执行父类构造方法
8.加载子类的非静态成员 属性 方法 块 构造方法
9. 执行块 执行子类构造方法
10.将对象空间的地址引用交给 变量来存储
设计模式
适配器模式 Adapter 用一个抽象方法去继承--接口 不用的东西就自定义异常
多态
同一个对象 体现出来的多种不同形态(身份) 将一种行为表现出不同的效果
要想实现多态的效果 需要现有继承关系
体现:
1.父类类型的引用 指向 子类的对象
Person p = new Teacher();
2.该引用只能调用父类中定义的属性或方法
3.如果子类中将父类的方法重写，那么调取方法后执行的结果是子类重写之后的那个结果
如果父类与子类有同名的属性 执行父类的属性
如果父类与子类有同名的方法(重载) 执行子类重写之后的方法
4.若想要调用子类中独有的成员
(强制类型转化) 造型 铸型 (向上/向下转型)
5.造型时(强制向下转型时) 可能会出现一个运行时异常
ClassCastException 造型 铸型 异常
如果想要避免造型的异常 可以用instanceof关键字来进行判断
对象 instanceof 类
内部类
指的是在Java中可以将一个类定义在另一个类的内部
内部类可以定义在 类的内部 (与类成员层次一致)
内部类可以定义在 方法/块内部 (与类成员相差一个层次 方法的局部变量一个层次)
LinkedBox Node内部类
*1.成员内部类
将一个类直接定义在类的里面，作为成员，与属性或方法层次一致
成员内部类可以与正常类一样 使用不同的修饰符来修饰
好处1.省略了一个.java文件 好处2.成员内部类中可以访问外部类的所有成员 包括私有的
若想要在内部类中通过对象.调用外部类成员 外部类.this.外部类成员;
内部类存在后 源代码进行编译 产生一个字节码 Demo$InnerDemo.class
2.局部内部类
将一个类定义在方法/块里面，作为成员的内部结构，与临时的局部变量一个层次
局部内部类像是一个局部的变量一样，不能用public protected private及static
只能用abstract或final
局部内部类命名规则Demo$1InnerTestMethod Demo$2InnerTestMethod
局部内部类使用的变量只能是final修饰
*3.匿名内部类
成员匿名内部类
局部匿名内部类
public interfase Test{
public void test();
}
Test t = new Test(){
public void test(){
}
};
通常接口或抽象类的具体子类这样写
开发中为了省略一个类文件 上述写法比较常见
匿名内部类很特殊 只有类体 没有类的所有结构( 修饰符 名字 继承 实现)
不能用任何修饰符来修饰 匿名内部类也没有构造方法
Swing 做一个按钮 绑定一个事件监听器
4.静态内部类
成员静态内部类
不需要外部类对象，通过正常的方式直接创建内部类
静态元素不能访问非静态成员(自己类和外部类)
数据类型
基本 8个
引用 数组[] 类class 抽象类abstract class 接口interface 枚举enum 注解@interface
枚举类
一个类中的对象 认为个数是有限且固定的 可以将每一个对象一一列举出来
1.试一试若没有枚举类型的时候 如何手动设计 (静态常量 单例模式) Day(类 当做描述星期 7个对象)
private构造方法
public static final属性 = new
2.JDK1.5版本之后可以直接定义enum类型
我们自己定义的enum类型直接默认继承Enum(java.lang包)
我们自己定义的enum类型不能再写extends 但是可以实现
Enum类型
有两个属性
name----->枚举对象的名字 name()获取name属性
ordinal--->枚举对象在类中罗列的顺序 类似index 也从0开始 ordinal()获取序号
一些常用的方法
valueOf() 通过给定的name获取对应的枚举对象
values() 获取全部的枚举对象 ---> 返回一个数组 Day[]
compareTo() 可以比较两个枚举对象 int
toString() 由于这个方法没有final修饰 可以覆盖(重写)
3.switch内部判断枚举的应用
4.我们也可以在enum中描述自己的一些属性或方法
必须在enum类中第一行 描述一下枚举的样子 最后需要分号结束;
可以定义自己的属性
类创建的过程中 帮我们创建枚举类型的对象
需要给枚举类型提供对应样子的构造方法 构造方法只能private修饰 可以重载
6.经常在笔试中出现的问题
Integer i1 = 10;
Integer i2 = 10;
Integer i3 = new Integer(10);
Integer i4 = new Integer(10);
System.out.println(i1==i2);// true--->如果数字范围超过127false
System.out.println(i1==i3);// false
System.out.println(i3==i4);// false
System.out.println(i1.equals(i2));//true
System.out.println(i1.equals(i3));//true
System.out.println(i3.equals(i4));//true
1.==与equals()区别
==可以比较基本数据类型 也可以比较引用数据类型 (变量中存储的内容)
如果比较基本类型比较是变量中存储的值
如果比较引用类型比较是变量中存储的地址引用
equals()是Object类中继承过来的方法 每一个引用类型都可以调用
默认继承的equals()方法比较与==一致 如果想要改变比较规则 可以重写equals方法
由于Integer类就重写了equals() 所以Integer比较的是数值
2.考察Integer类加载的时候 自己有一个静态的空间
空间内立即加载 Integer类型的数组 内存储256个Integer对象 -128 ~ 127
如果我们用的对象范围在这之内Integer i1 = 10; 直接取静态区中找对应的对象
如果我们用的对象范围超出了这个Integer i1 = 1000; 会帮我们创建一个新的Integer对象
与数学相关的类
Math
1.所属的包java.lang
2.Math构造方法是私有的 我们不能直接调用创建对象
3.由于Math中提供的属性及方法都是static 不需要创建对象
4.常用的方法
abs()返回给定数字的绝对值 (参数 int long float double)
double = ceil()向上取整
double = floor()向下取整
int = round() 四舍五入的整数
double = rint()临近的整数 如果两边距离一样 则返回偶数
max(a,b) min(a,b) (参数int long float double)
pow(a,b) a的b次方 (参数double 返回值double)
sqrt(double a) 获取给定参数的平方根
double = random(); 随机产生一个 [0.0--1.0)
5.Math.random()计算小数的时候精确程度可能有些损失
0-9之间的随机整数
int value = (int)(Math.random()*10);
5.0---10.9之间的小数
(Math.random()*6)+5
0.0---0.99999 * 6
(0.0---5.49999)+5
Random类
1.在java.util包中的类 需要import导入
2.没有任何继承关系 默认继承Object类
3.查找构造方法--->如何创建对象
Random r = new Random();
4.类中提供的常用方法
r.nextInt(); 随机产生 int取值范围的整数 有正有负
r.nextInt(int bound); 随机产生一个 [0--bound) 整数
注意bound必须为正数 否则会出现如下的运行时异常
IllegalArgumentException
r.nextFloat() 随机产生一个 [0.0---1.0)
r.nextBoolean() 随机产生一个boolean值 true false
包装类 数学相关
Scanner类
1.所属的包java.util包 需要import导包
2.通过一个带输入流的构造方法创建对象
3.常用方法 nextInt() nextFloat() next() nextLine()
System类
1.所属的包java.lang包 不需要导入
2.不需要创建对象 通过类名就可以访问
3.有三个属性及若干的方法
三个属性out in err
方法gc() exit(0); currentTimeMillis();
日期相关
Date类
1.通常使用的是java.util包
2.导包 拿来使用 构建对象
3.通常使用无参数的构造方法 或者带long构造方法
4.Date类中常用的方法
before(); after();
setTime() getTime();----->long
compareTo(); -1 1 0
5.可以处理一个Date日期的格式
String类---->引用类型 java.lang包
0.常见的String笔试题
== equals方法的区别
==可以比较基本类型 可以比较引用类型
比较基本类型比较值 比较引用类型比较地址
equals只能比较引用类型(方法)
默认比较地址this==obj
如果想要修改其比较规则 可以重写equals方法
通常重写equals方法时会伴随着重写hashCode方法
比如String类 比如Integer
*String的不可变特性
长度及内容
String与StringBuffer区别
StringBuffer与StringBuilder区别
String对象的存储
"abc"---->字符串常量池
new String("abc")--->堆内存
"a"+"b"+"c"+"d"
*String中常用的方法
1.存在哪儿 java.lang包
没有任何继承关系 实现三个接口Serializable, CharSequence, Comparable<String>
2.如何构建对象
String str = "abc"; //直接将字符串常量赋值给str (字符串常量池)
String str = new String();//无参数构造方法创建空的对象
String str = new String("abc");//带string参数的构造方法创建对象
String str = new String(byte[] )//将数组中的每一个元素转化成对应的char 组合成String
String str = new String(char[] )//将数组中的每一个char元素拼接成最终的String
3.String的不可变特性
String类中包含一个private final char[] value;
体现在两个地方 长度及内容
长度--->final修饰的数组 数组长度本身不变 final修饰数组的地址也不变
内容--->private修饰的属性 不能在类的外部访问
*4.常用的方法
boolean = equals(Object obj);
//继承自Object 重写啦 比较两个字串中的字面值是否相等
int = hashCode();
//继承自Object 重写啦 将当前字符串的每一个char元素拆开 乘以31求和
int = compareTo(String str);
//实现自Comparable接口 实现啦 按照字典(Unicode编码)索引的顺序比较
String = toString();
//继承自Object 重写啦 不再输出 类名@hashCode 字符串中的字面值
--------------------------------------------------------------------
char = charAt(int index);//"abc" 0-->a
//返回给定index对应位置的那个char值
int = codePointAt(int index);//"abc" 0-->97
//返回给定index对应位置的那个char所对应的code码
int = length();
//返回字符串的长度
String = concat(String);
//将给定的字符串拼接在当前字符串之后
//自己回去查看API文档
-----------------------------------------------------------------------------------
5.char = charAt(int index);
返回给定index位置对应的字符
int = codePointAt(int index);
返回给定index位置对应字符的code码
6.int = length();
返回字符串的长度 (其实就是底层char[] value属性的长度)
注意: 区别数组length是属性 String的length()方法 集合size()方法
7.String = concat(String str);
将给定的str拼接在当前String对象的后面
注意: 方法执行完毕需要接受返回值 String的不可变特性
concat方法与 +拼接的性能问题
开发中若遇到频繁的拼接字符串--->通常使用StringBuilder/StringBuffer
========================================================
8.boolean = contains(CharSequence s);
判断给定的s是否在字符串中存在
9. startsWith(String prefix);
endsWith(String suffix);
判断此字符串是否已xx开头/结尾
10.byte[] = getBytes(); ---> getBytes(String charsetName);
char[] = toCharArray();
将当前的字符串转化成数组 "我爱你中国" char[] '我' '爱' '你' '中' '国'
11. int index = indexOf(int/String str [,int fromIndex] ); 四个方法重载
找寻给定的元素在字符串中第一次出现的索引位置 若字符串不存在则返回-1
lastIndexOf(int/String str , [int fromIndex]);
找寻给定的元素在字符串中最后一次出现的索引位置 若不存在则返回-1
12.boolean = isEmpty();
判断当前字符串是否为空字符串 (length是否为0)
注意： 与null之间的区别
13.replace();
replaceAll();
replaceFirst(); 换第一次出现的那个字串
将给定的字符串替换成另外的字符串
14.String[] = split(String regex [,int limit限度界限]);
按照给定的表达式将原来的字符串拆分开的
15.String = substring(int beginIndex [,int endIndex]);
将当前的字符串截取一部分
从beginIndex开始至endIndex结束 [beginIndex,endIndex)
若endIndex不写 则默认到字符串最后
16.String = toUpperCase();
String = toLowerCase();
将全部字符串转换成大写/小写
17.String = trim();
去掉字符串前后多余的空格
18.boolean = matches(String regex)
regular有规律的 expression表达式
正则表达式
19.常用的方法
第一梯队(重写)
equals hashCode compareTo toString
第二梯队(常用)
charAt() codePointAt()
indexOf() lastIndexOf()
substring() split() replace()
length() concat() contains(); trim();
getBytes() toCharArray() matches()
第三梯队(一般)
toUpperCase() toLowerCase()
startsWith() endsWith();
isEmpty();
知识总结
1.StringBuilder类不一定需要 是为了避免String频繁拼接修改字符串信息的时候才用的
底层数组是可变的 提高了性能
2.常用方法
与String类不同的独有方法
append() insert() delete() deleteCharAt() reverse()
与String类相同的方法
length() charAt() codePointAt() indexOf() lastIndexOf()
substring() replace()名字相同 用法不一致
不是很常用的方法
ensureCapacity() capacity() setLength() trimToSize(); setCharAt();
3.String家族笔试中经常容易考察的知识点
1.String所属的包 继承关系 实现接口
java.lang 继承Object 接口Serializable,CharSequence,Comparable
2.String构建方式
常量 构造方法
3.String对象内存结构
字符串常量区 new堆内存对象
== equals()区别
"a"+"b"+"c"
4.String不可变特性
长度及内容
5.String中的常用方法---与StringBuilder的区别
concat(); toUpperCase();
6.String和StringBuilder区别 | String和StringBuffer区别
String不可变字符串
JDK1.0
有一个接口Comparable
不可变体现在长度及内容
有一些方法StringBuilder没有 concat compareTo toUpperCase
StringBuilder可变字符串
JDK1.5
有一个接口Appendable
可变字符串 没有final修饰 底层可以进行数组扩容
有一些方法String没有 append() insert() delete() reverse()
7.StringBuffer和StringBuilder的不同
StringBuffer早期版本1.0
StringBuilder后来的版本1.5
早期版本 线程同步 安全性比较高 执行效率相对较低
后期版本 线程非同步 安全性比较低 执行效率相对较高
Regular有规律的 Expression表达式
正则表达式regex
一个带有一定规律的表达式
匹配字符串格式的
正则表达式通常的作用如下:
1.字符串的格式校验 String类中提供的一个方法 boolean = str.matches("regex");
2.字符串的拆分及替换 String类中提供的方法replace split
3.字符串的查找 Pattern模式 Matcher匹配器
如下的所有都用来描述字符的信息
[abc] abc其中的一个
[^abc] 不能是abc其中的一个 其他都可以
[a-zA-Z] 表示必须是这两个范围内的
[a-z&&[^bc]] 表示a-z其中的一个但不能是b和c
| 或者
. 代表任意一个字符
\d digit数字 [0-9]
\D 非数字 [^0-9]
\s space留白 一个空格 一个回车 一个换行。。。
\S 非留白
\w word单词 [0-9A-Za-z] 数字或字母都可以
\W 非单词 [^0-9A-Za-z]
如下的所有都用来描述字符出现的次数
? 0-1次 [0-9]?
* 0-n次
+ 1-n次
{n} 固定n次
{n,} 至少出现n次
{m,n} m-n次
知识回顾
集合
集合是用来存储一组元素----容器 与数组类似
数组创建后长度不可以再次改变 集合创建后长度是可以改变 (数据结构 Array Linked Hash Tree)
集合的分支体系
Collection Map
以value形式存储 以key-value形式存储
List Set Queue
有序可重复 无序无重复 key无序无重复 value无序可以重复
java.util包
*ArrayList
1.底层是利用(动态)数组形式实现 1.5
2.ArrayList特点适合遍历轮询 不适合插入删除
3.如何构建一个ArrayList对象
无参数构造方法 带默认容量构造方法
4.ArrayList中常用的方法
增删改查 add(E e) remove(index) set(index value) get(index) size()
类中其他常用的方法
addAll并集 removeAll差集 ratainAll交集
indexOf() lastIndexOf() contains() List=subList()
isEmpty() clear() ensureCapacity() iterator();迭代器
toArray(T[] x); trimToSize();
5.泛型
用来规定数据类型
注意: 泛型 造型
在类或接口描述的时候 可以使用某种符号来表示一个未知的类型
在类型使用的时候 需要一个具体类型来代替
注意: 泛型需要使用引用数据类型来代替
1.泛型类 2.泛型接口 3.泛型方法 4.方法参数泛型限制
知识回顾
集合
Collection Map
以value形式存储 以key-value形式存储
List Queue Set
有序可重复 无序无重复 key无序无重复value无序可重复
*ArrayList HashSet HashMap
Vector TreeSet TreeMap
Stack(LIFO)
*LinkedList
add() add()
remove() remove()
set() 无
get() iterator()
size() size()
5.map集合在什么情形下用?
1.想要存储一组元素
数组 or 集合 如果存储的元素以后长度不变用数组 如果长度以后不确定 用集合
2.如果发现长度以后不确定--->集合
List Set Map
List家族有序的 存储有顺序用这个
ArrayList 更适合遍历轮询
LinkedList 更适合插入和删除
Stack LIFO
Set家族无重复 存储元素希望自动去掉重复元素用这个
Hash 性能更高
Tree 希望存进去的元素自动去重复 同时还能自动排序
Map家族k-v 通过唯一的k快速找寻v用这个
Hash 性能更高
Tree 希望存进去的元素key自动排序
遍历map集合? key不一定什么样
获取到所有的key 遍历key 通过key获取value
Set<Key> = keySet()获取全部的key
Set<Entry> = entrySet();
1.InputMisMatchException 输入不匹配
int value = input.nextInt();// abc
*2.NumberFormatException 数字格式化
int value = Integer.parseInt("123.45");
3.NegativeArraySizeException 数组长度负数
int[] array = new int[-2];
*4.ArrayIndexOutOfBoundsException 数组索引越界
int[] array = {1,2,3};
array[5];
*5.NullPointerException 空指针异常
int[][] array = new int[3][];
array[0][0] =10;
Person p = null;
p.getName();
6.ArithmeticException 数字异常
10/0 整数不允许除以0 Infinity小数除以0会产生无穷
*7.ClassCastException 造型异常
Person p = new Teacher();
Student s = (Student)p;
*8.StringIndexOutOfBoundsException 字符串越界
String str = "abc";
str.charAt(5);
*9.IndexOutOfBoundsException 集合越界
List家族
ArrayList list = new ArrayList();
list.add(); list.add(); list.add();
list.get(5);
10.IllegalArgumentException 非法参数异常
ArrayList list = new ArrayList(-1);
I/O相关 输入/输出 流(数据流动)
数据流动的方向 读数据(输入Input) 写数据(输出output)
3.File与真实硬盘中的文件或文件夹 不是一个东西
File是在内存中的一个对象<---映射--->硬盘上的文件或文件夹
4.File类中的常用的方法(豪华版)
canRead() canWrite() isHidden() isFile() isDirectory()
length()获取文件中字节的个数
lastModified()获取文件最后的修改时间--->毫秒值
*String path = getAbsolutePath() 获取文件的绝对路径 D://test//Test.txt
绝对路径<---->相对路径
绝对路径可以通过完整的字符串 定位盘符 文件夹 文件
相对路径没有盘符的写法 当前工程(项目)所在的位置找寻
C:\Users\Administrator\IdeaProjects\TestFile
String name = getName() 获取文件的名字 Test.txt
*boolean = createNewFile() 创建新的文件
*boolean = mkdir 创建新的文件夹 外层没有 不能创建
*boolean = mkdirs 创建新的文件夹 外层没有 可以自动创建
String pname = getParent() 获取当前file的父亲file名字
*File file = getParentFile() 获取当前file的父亲file对象
String[] names = list() 获取当前file的所有儿子名字
*File[] files = listFiles() 获取当前file的所有儿子对象
*boolean = delete() 删除文件或空的文件夹 不能删除带元素的文件夹
4.File类中常用的方法(精简版)
canRead canWrite isHidden *length lastModifered isFile isDirectory
*getAbsolutePath() getName()
绝对路径---相对路径(工程的根目录去找)
*createNewFile() *mkdir() *mkdirs()
*File = getParentFile() getParent()
*File[] = listFiles() list();
*delete()
字节型文件输入流
FileInputStream
1.包 java.io
2.了解一下继承关系 InputStream类 字节型输入流的父类
3.创建对象
调用一个带File类型的构造方法
调用一个带String类型的构造方法
4.常用方法
int code = read(); 每次从流管道中读取一个字节 返回字节的code码
*int count = read(byte[] ) 每次从流管道中读取若干个字节 存入数组内 返回有效元素个数
int count = available(); 返回流管道中还有多少缓存的字节数
skip(long n) 跳过几个字节 读取
多线程--->利用几个线程同时读取文件
10000字节 5个小人同时读取
1-2000 2001-4000 4001-6000 6001-8000 8001-10000
D当做服务器 E当做客户端
*close() 将流管道关闭---必须要做 最好放在finally里 注意代码的健壮性 判断严谨
字节型文件输出流
FileOutputStream 将数据写入文件中
1. java.io
2.继承OutputStream 所有字节型输出流的父类
3.创建对象
调用一个带File参数 还有File boolean重载
调用一个带String参数 还有String boolean重载
4.常用方法
write(int code); 将给定code对应的字符写入文件 '='
write(byte[]) 将数组中的全部字节写入文件 getByte()
flush(); 将管道内的字节推入(刷新)文件
close(); 注意在finally中关闭
字节型文件流
FileInputStream
FileOutputStream
1.所在的包java.io
2.各自继承关系
InputStream/OutputStream
3.构造方法
利用file对象构建
new FileInputStream(file); new OutputStream(file,true);
利用string对象构建
new FileInputStream(""); new OutputStream("",true);
4.常用的方法操作文件中的内容
int code = read(); write(int code);
int count = read(byte[]) write(byte[]);
close(); close();
available(); 多少字节缓存 flush();
skip(long count)
1.所在的包java.io
2.各自继承关系
InputStream/OutputStream
3.构造方法
利用file对象构建
new FileInputStream(file); new OutputStream(file,true);
利用string对象构建
new FileInputStream(""); new OutputStream("",true);
4.常用的方法操作文件中的内容
int code = read(); write(int code);
int count = read(byte[]) write(byte[]);
close(); close();
available(); 多少字节缓存 flush();
skip(long count)
4.通过上述的生产消费者模型
做一个非常完整而且安全的模型
1.利用线程安全锁 特征修饰符synchronized
两种不同的写法
不管怎么写 锁定的永远是对象
2.利用方法控制线程状态的来回切换
wait
notify notifyAll
上述三个方法都是Object类中的方法
3.Thread类中的方法
sleep方法 静态方法(参数long 毫秒值)
setPriority(10); getPriority();
设置/获取线程的优先级 1-10
数字越高优先级越高 更加容易获取CPU分配的资源碎片
4.笔试题
程序 进程 线程 概念的区别
线程的创建方式
线程的几种状态 如何切换
sleep方法 wait方法的区别
1.类 Thread类 Object类
2.调用 静态 类名. 对象.
3.理解 哪个位置调用 对象调用方法
哪个线程等待 访问对象的其他线程等待
4.唤醒 不需要别人 需要其他对象调用notify唤醒
5.锁 不会释放锁 等待后会释放锁
Class 用来描述类本身
Package 用来描述类所属的包
Field 用来描述类中的属性
Method 用来描述类中的方法
Constructor 用来描述类中的构造方法
Annotation 用来描述类中的注解
1.如何获取Class
如下三种方式
Class clazz = Class.forName("包名.类名"); eg：较为普通的(包名.类名)
Class clazz = 类名.class; eg：进行mysql的连接--获取当前系统的I/O流
Class clazz = 对象.getClass();//Object类中的方法 eg：改变String中的值(str.getClass)
2.Class中的常用方法
1.int result = getModifiers(); 获取类的修饰符(权限 特征)
每一个修饰符 用一个整数来进行表示
0开始---0 1 2 4 8 16 32 64 128 256 512
0--默认不写 1--public 2--private 4--protected
8--static 16--final 32--synchronized 64volatile
128--transient 256--native 512--interface 1024--abstract
2.String name = getName();获取名字
3.String simpleName = getSimpleName();简单名
4.Package p = getPackage();
p.getName();
5.Class sclazz = getSuperClass();//获取超类(父类)
6.Class[] classes = getInterface();
-----------------------------------------------------------------------
7.Object obj = newInstance();//默认调用无参数构造方法创建对象
8.Field f = getField("属性名");
Field[] fs = getFields();
如上的两个方法只能获取公有的属性 但是包含继承过来的父类属性
9.getDeclaredField("属性");
Field[] fs = getDeclaredFields();
如上的两个方法能获取公有的和私有的属性 但是只能获取本类中的属性
3.Field类中的常用方法
int = getModifers()
Class = getType()
String = getName()
操作属性 向里面存值
set(对象,值)
操作属性 从里面取值
值 = get(对象)
setAccessable(true); 可以修改属性被操作
对象 = new();//创建对象空间 当前对象空间里有自己的一套元素(属性 方法)
对象.属性 = 值;
属性 = 类.getField();
属性.赋值(哪个对象,值);
值 = 对象.属性 值 = 属性.取值(哪个对象)
简洁版----------------------------------------------------------------------------------------------
如何获取Class
1.Class中静态方法 forName(“类全名”)
2.类.class关键字
3.对象引用.getClass()方法
Class中的常用方法
int = getModifiers(); 获取类的修饰符(权限+特征)
String = getName(); 获取类的全名(包名.类名)
String = getSimpleName(); 获取类简单名(只有类名 缺少包)
Class = getSuperClass(); 获取当前类父类的对应Class
Class[] = getInterfaces(); 获取当前类父亲接口
Package p = getPackage(); 获取当前类所属的包
p.getName(); 获取包名(Package类中的方法)
Class[] = getClasses(); 获取类中的内部类
--------------------------------------------------------------------
Object = newInstance(); 获取当前类的对象(相当于调用类中无参数的构造方法)
若类中不存在无参数构造方法 抛出异常NoSuchMethodException
Field = getField("属性名"); 获取类中的属性(公有的 自己类+父类)
Field[] = getFields(); 获取类中的全部属性(公有的 自己类+父类)
Field = getDeclaredField("属性名"); 获取当前类中的属性(公有+私有 自己类)
Field = getDeclaredFields(); 获取当前类中全部的属性(公有+私有 自己类)
Field类中的常用方法
int = getModifiers 获取属性修饰符(权限+特征)
Class = getType 获取属性的类型对应的那个class
String = getName 获取属性的名字
操作属性
set(对象,值); 给属性赋值
Object = get(对象) 从某个对象内取得属性的值
如果是私有属性不能直接操作的
setAccessable(true); 设置一个使用权 准入
经典样例
//通过一个Class对象来操作Person.class类文件
Class clazz = Class.forName(“testreflect.Person”);
Person p = (Person)clazz.newInstance();
//通过clazz来获取类中的属性
Field f = clazz.getDeclaredField(“name”);//name名字
System.out.println(f.getName());
f.setAccessible(true);//表示私有属性可以直接被操作
f.set(p,“郑中拓”);
String value = (String)f.get§;
System.out.println(value);
如何操作类中的方法
Class类中的方法
Method m = class.getMethod("方法名",Class...参数类型); 获取公有的方法(自己类+父类)
Method[] = clazz.getMethods(); 获取所有的方法(公有 自己+父类)
Method = getDeclaredMethod("方法名字",参数类型的class...) 获取一个方法(自己类 公有 私有)
Method[] = getDeclaredMethods(); 获取全部的方法(自己类 公有 私有)
获取构造方法
Constructor = clazz.getConstructor(Class...参数类型)
Constructor[] cons = clazz.getConstructors();
clazz.getDeclaredConstructor();
clazz.getDeclaredConstructors();
Method类中的常用
int mm = m.getModifiers();//获取方法的修饰符(权限+特征)
Class mrt = m.getReturnType();//获取返回值数据类型
String mn = m.getName();//获取方法的名字
Class[] mpts = m.getParameterTypes();//获取方法参数列表的类型
Class[] mets = m.getExceptionTypes();//获取方法抛出异常的类型
如何操作方法
调用方法 让他执行一次
Object result = invoke(对象,执行方法需要传递的所有参数...);
若方法是私有的方法 不允许操作
可以设置setAccessable(true) 设置方法使用权 准入
Constructor类中的常用方法
con.getModifiers();
con.getName();
con.getParameterTypes();
con.getExceptionTypes();
如何操作构造方法
执行一次 创建对象
Object = newInstance(执行构造方法时的所有参数);
con.setAccessible(true);
541
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
