强制类型转换：小数据向大数据进行转换 相当于小杯子向大杯子中倒入东西，会自动进行强制类型转换；相反，大容器向小容器中添加水 则会强制进行强制类型转换
变量命名：第一个字符不能使用数字
变量的第一个字符只能使用字母 $和 _ 下划线
变量声明在一个类下面，该变量叫做字段或属性，成员变量
变量声明在一个方法中，那么该参数作用域只能是方法内的所有代码，其他方法不能访问该参数，类里面的也不能访问
声明在方法内的变量 局部变量，作用域在声明开始的位置到其所处的块结束位置
属性的作用域在方法中，参数的作用域也在方法中，如果属性和参数命名相同了的话 取参数中的数值
Final类别要求
Final参数修饰变量只能改变一次 final修饰类标识类不能被继承 修饰方法标识不能被重写
Final 修饰基本类型变量，表示该变量只有一次赋值机会
Final 常量表示不能够发生变化（可以公开表示不会被修改的）
String类 属于Final类型不能够被继承
Scanner 部分内容：
引用scanner 需要引入的部分：import java.util.Scanner; //ctrl shift +o 快捷添加包
Scanner 函数 需要引入包 java.Util.Scanner scanner s = new scanner（System.in）
String a =s.nextLine（） 输入一个字符形式的内容//
输入一个float形式的内容 float a = s.NextFloat
特殊情况：读取nextint形式 会先进行读取整数在进行读取字符串 nextint 仅仅读取数字信息，故因此要执行了两次的 nextline
Scanner s = new scanner（System.in）
System.out。println（“请输入身高”）
Float height = s.nextFloat（）；
System.out。println（“请输入体重”）
Float weight = s.nextFloat（）； //只需要一个sacnner即可实现对应公共
（Ps:float中的字面值中对应的数值才需要加f eg：1.74f）
Ps：nextInt使用后会遗留一个空白符"\r"导致nextLine()结束
a^b 异或进行计算 不同为1 相同为0
长路| 短路|| （长短路或二者都是真为真，都为假为假） 长路& 短路&&
闰年：year%4==0&&year%100!=0||year%400 = =0
Switch 中的默认参数需要给最初的初始化的数值内容 （注意默认的输入的时候的参数问题） switch中的每一项输出完之后需要有break参数进行处理
（Switch后面要有break 来进行输出的控制）
Do（循环体结构） while（循环条件）至少会被执行一次
while 成立的话会一直被循环执行
continue下面的代码不执行了执行下一次循环 continue 继续下一次循环
（例题涉及到的忽略某些项） if（num%2==0）{continue sys。。} 当是偶数的时候就会自动跳过最后的输出执行下一次循环
Break 结束当前循环
While(1)he while(true)等价
If else 中没有括号会执行最近的一条
Math.random（） //设置出随机数随机数的默认范围是0-1 Ps: 默认的时候math的包时自动导入的，不需要手动添加。 一般执行的时候都 math.random*100 进行扩大
数组：int a[] = new int a[]{100,200,300}
/ int a []; a= new int a[3 int b [] = {100,200}
数组不能直接输出 需要重新进行for循环遍历才可以 如
System.out.println(a[i]+"") 是错误的
复制数组：System.arraycopy(src,srcPos,dest,destPos,length)
源数组；复制的起始位置；目标数组；复制到目标数组的起始位置；复制的长度
Int a[] = new int[]{1,2,3,4}
数组复制：int[] b = Arrays.copyOfRange(a, 0, 3);
数组Arrays 的作用
Arrays.CopyOfRange 第一个参数表示源数组
// 第二个参数表示开始位置(取得到)
// 第三个参数表示结束位置(取不到)
String context =sArrays.toString(a);
Arrays 提供了sort方法进行排序
Arrays。Sort(a) 其中a为数组名 PS：sort方法只能针对一维数组。
Tips:
Sort处理二维数组的时候 限制性System.Arraycopy 进行数组复制到一个一维数组中然后在使用 sort进行排序；最后在复制回二维数组中。 ！！！！！！（二维数组转一维数组
(大问题)
。。。。。。。。。。。。。。。。。。
类和对象 Hero h = new Hero（） new hero 仅代表创建的了一个Hero对象
H这个变量是hero类型 也叫做引用 = 表示h这个引用代表右侧创建的对象 也叫做指向
即h指向hero对象
多个引用 一个对象： Hero h1= new Hero（）； Hero h2= h1；///h2指向h1指向的对象
一个引用多个对象时，同一时间只能指向一个对象 Ps；=右侧为指向的谁
Hero h = new Hero（）； （1） （2） h = new Hero（）； 此时1 已失效
方法的重载：方法名一样，但是参数不一样；
形参中的括号中的三个省略号代表 fun（Hero…heros ） 中的省略号代表可以和多个参数进行匹配
PS:其中的最后一项会默认的变成对应形式的复数形式，访问对应的成员变量时候需要执行 heros[i].name 执行循环的时候执行 直接执行heros.name不会成立
实例化：一个类创造一个对象是类的实例化
构造方法：方法名和类名 相同（包括大小写） 且没有返回类型 public Hero（）{syso}
实例化一个对象的时候必须用构造方法
如果不写系统会默认给一个 无参数的构造方法 一旦有有参的构造方法就不会再提供无参数的构造方法
This中的关键字带表当前对象 可以理解为“我” 的意思/表示当前对象
ShowaddressMemory 会显示当前的虚拟地址
//通过this访问属性
public void setName3(String name){
//name代表的是参数name
//this.name代表的是属性name
this.name = name;
}
Tips：当参数名和属性名相同的时候用 this 执行操作 （参数名和属性名相同时应用
）
参数名和属性名相同的时候，方法体中只能访问到参数name
如果要在一个构造方法中，调用另一个构造方法，可以使用this() eg:this(name)
前提是有对应的要调用的方法 再在另一个构造方法（和类名相同的构造方法）中进行引用对应的方法
且另一个构造方法中也要是构造函数
。。。。
变量类型和类类型
（形参是）引用类型（包括类，数组，接口）的参数传递：此时实参和形参公用同一块地址数值都会发生改变
基本类型的参数传递：实参不会有影响
变量是类类型的参数此时的变量就不代表指向的意思而是代表引用？？？？？？（没太懂的地方）
包：不同包之间的引用需要使用import
变量类型：成员变量的四种修饰符：private protected package(默认的类型) public-共有的（没有修饰符的默认为package类型的）
成员变量默认的修饰符是：public static final
类之间的关系：自身 同包子类 不同包子类 同包类 其他类
- 属性通常使用private封装起来
2. 方法一般使用public用于被调用
3. 会被子类继承的方法，通常使用protected
Private《package《public
当一个属性被static修饰的变量叫做类属性，也叫做静态属性；类属性所有对象共享一个值
类属性（也叫做静态属性） 类属性可以理解为有static的属性，同理类变量
对象属性（也叫做实例属性，非静态属性）
访问类属性：对象.类属性 // 类.类属性 （推荐用第二种）
对象属性适合每个角色不同的（如英雄名）；类属性适合所有角色共享的（如设置血量上限）
类方法在main中可以不用对象直接用：类名。方法调用
实例方法/对象方法/非静态方法必须要在main中有一个对象才能调用（类名实例化一个引用对象，引用.属性的形式调用）
（类方法调用同类属性一样）
对象属性初始化：（三种形式）：
1. 声明该属性的时候初始化
2. 构造方法中初始化 3. 初始化块 eg；{ maxp =30;}
类属性初始化（两种）
1. 声明该属性的时候初始化
2. 静态初始化块 如：static{ item = 6 } //访问时类属性名.属性
对象属性的初始化的先后顺序：构造方法》初始化》声明块
JVM虚拟机
单例模式：一个类在一个JVM中，只有一个实例存在
饿汉式单例模式：私有化其构造方法，让外部无法通过new来进行实例化；
Public class GiantFragon
//准备一个类属性指向一个实例化对象，因为是类属性所以只有一个
Private static GiantDragon instance = new GiantDragon（）
//每一次都是获取同一个对象
Public static GianDragon getInstance（）{ return instance } //外部调用者无论如何都会创建一个实例
懒汉式单例模式：只有在调用getInstance的时候才会创建实例
饿汉和懒汉式区别：饿汉相当于立即加载；懒汉相当于延时加载
（饿汉模式构造类变量的时候就直接进行初始化，懒汉模式 需要时候在进行创建）
面试题：单例模式三元素：******
- 构造方法私有化
2.静态属性指向实例
3.public static 的getInstance方法，返回第二步的静态属性
（例上面的静态属性 instance）
枚举类型enum 也是一种特殊的类。
Public enum Season{ spring summer autumn } //可以很方便的定义常量
（可以结合switch 将属性锁死在这几个范围之内）
。。。。。。。。。。。。。。。。。。。。。。。。。。。。
接口 @override 子类重写父类的方法
引用类型和对象类型不一致情况下的转换问题 （同行情况下引用类型和对象类型是一致的）
Ps子类转父类：（向上转型）所有的子类转向父类都是行得通的 理解为：把子类当作父类来用
没有继承关系的两个类互相转换一定会失败
Instance关键字用来判断是否为一个类
重写：子类可以继承父类的对象方法，继承后重新提供该方法就叫做方法的重写也叫覆盖 override
。。。9.14
操作符的多态： +号的两侧都是整型，那么+代表 数字相加；如果任意一个是字符串，那么就代表的是字符串的连接
实现类的多态：父类的（接口）引用指向子类对象；调用的方法有重写
方法的重写是子类覆盖父类的对象方法 隐藏是子类覆盖父类的类方法
Super关键字 子类构造方法会默认调用父类的 无参的构造方法
Super指的是当前对象的直接父类对象
能调用父类的成员变量super.，成员方法super.成员方法（实参列表）；构造方法super（实参列表）
This和super关系？ ： **** 核心内容
this现在子类找找不到到父类找；super直接越过子类直接向父类进行查找
当没有写构造方法的时候，JVM会默认的提供一个无参的构造方法
当写了构造方法之后，JVM将不提供无参的构造方法，需要自己写一个
Super注意点：（1）在子类重写方法中需要调用关键字super （调用子类会直接进行死循环）
（2）子类的成员变量和父类的成员变量同名如何区分？
局部变量直接属性即可eg （name）实现；
子类通过this.name实现
父类的成员变量通过super.name实现
（3）子类无法继承父类的成员变量的方法和属性 且子类无法继承父类的静态变量和静态方法 （继承是对象之间的关系，没有静态的关系）
子类中如果想操作父类私有方法，需要通过getter setter的方法来进行执行
（父类中增加getName（），setName方法，子类中输出通过 superr.getName的方法即可）
超类：Object类是所有类的父类，默认是继承了Object类
Object提供一个toString 方法
垃圾回收：一个对象没有任何引用指向时，满足垃圾回收的条件（finalize方法会被调用，虚拟机JVM直接调用） public void finalize（）方法 实现
Instanceof 用来判断和类名是否相同 hashcode 返回一个对象的哈希值
Object线程：wait notify notifyAll 方法
内部类：非静态内部类，静态内部类，匿名类，本地类
非静态内部类可以在类里面定义：语法: new 外部类().new 内部类()
静态内部类：语法：new 外部类.静态内部类();
PS：不需要一个外部类的实例为基础；不可以访问外部类的实例属性和方法；也可以访问外部类的私有静态成员外
匿名类指的是在声明一个类的同时实例化它
JDK默认方法： review 该方法有实现体 并被声明为了default类型
Default public void 方法名（）{}
UML图表示
方法有下划线，表示是构造方法
抽象方法：子类必须覆盖重写 父类当中所有的抽象方法；不能直接创建new抽象类对象。
必须用一个子类，继承抽象的父类； public abstract void Animal（）
- 抽象类不能创建对象
- 抽象类可以有构造方法
- 抽象类中不一定包含抽象方法
- 抽象类的子类，必须覆盖重写所有的抽象方法
抽象类的子类需要对自己的属性值进行赋值的时候通过对 抽象类的属性的set和get的属性进行创建 ——子类通过创建对象后的 属性值的set 和get方法对属性进行赋值
受保护类型的量 protected
子类继承父类的时候会自动继承默认的构造函数(这里指无参的构造函数)。而子类里面已经有一个带有参数的构造函数了，如果没有写那个默认的不带参数的构造函数的话，继承的时候就会报错
//9.15
基本类型转为Integer类型的量 ——在Integer 类型new新的变量的时候括号中给出即可
Int o = 3；
integer o = new Integer（O） //基本类型转为Integer类型 /基本类型转为封装类型
int S = o.IntValue（） //Integer类型转为基本类型 别忘了后面的括号 /封装类型转为基本类型
Integer 是int 的包装类 Integer必须实例化后才能用使用 Integer 默认值为null
数字封装类有 Byte（占一个字节）,Short,Integer,Long,Float,Double 这些类都是抽象类Number的子类
基本类型对应的类的类型就是其封装类 如int 的封装类为Integer ；Char对应的封装类 Character
装箱：不需要调用构造方法，通过=符号自动把 基本类型 转换为 类类型 自动转换
Int I = 3 ； Integer it=i；
自动拆箱： int i3 = it.intValue（）； int K = it （也是用= 实现）
装箱：int——integer 拆箱：Integer——int
Int的最大值可以通过其对应的封装类Integer.MAXVALUE/MINVALUE 来实现
Byte和Integer之间能不能进行自动拆箱和自动装箱
小的（byte）可以向大的（Integer）装箱 反之不成立
数字转字符串
String st = String.valueof（i） 法1
Integer it = I ； String str2 = it.toString() ; 法2
字符串转数字
（调用Integer的静态方法parselnt）
String str = “999” int i= Integer.parselnt（str）
///9.18
Math类别：
Math.round math. PI math.E //（自然对数）Math.sqrt（）//平方
Math.pow（2,3）//2的三次方 Math.random（）//随机数
Round () 四舍五入的方法 执行为math。Round（g）
判断是否为质数可以用Sqrt的方法来执行
%s 表示字符串
Syso.printf 和SYSO.format 的作用效果相同
使用%n 可以实现跨平台的 换行实现 \n 换行符 \r回车符
%-8d 表示左对齐总长度为8 %8d表示右对齐
%08d 表示总长度为8 不足的位补0
Char 保存一个字符的时候使用
Character 的 含有的方法：
(Character.isDigit('a')); //判断是否为数字
(Character.isWhitespace(' ')); //是否是空白
(Character.isUpperCase('a')); //是否是大写
(Character.isLowerCase('a')); //是否是小写
(Character.toUpperCase('a')); //转换为大写
Character.toLowerCase('A')); //转换为小写
String a = 'a'; //不能够直接把一个字符转换成字符串
String a2 = Character.toString('a'); //转换为字符串
tocharArray() //字符串转为字符数组
String 被修饰为final是不能被继承的 因为String 不能被继承
CharAt 获取字符 tocharArray获取对应的字符数组 substring截取字符串
Split 分隔 trim去掉首位空格
属性名.方法大小写 String name = “”
Substring indesOf(判断字符或字符串第一次出现的位置)
RepaceALL 替换所有的 ReplaceFirst 只替换一个
name.toLowerCase() name.toUpperCase()
StringBuffer 是可变长的字符串
StringBuffer的方法 append（追加delete（删除）insert（插入）reverse（反转）
Capacity 容量
//9.23
Java 的日期类 java.Util.Date
Java.sql.Date 是给数据库访问的时候使用的
Date(5000)//代表5000毫秒 等于5秒 getTime（）得到一个long形的整数
日期格式化类：SimpleDateFormat
//y 代表年
//M 代表月
//d 代表日
//H 代表24进制的小时
//h 代表12进制的小时
//m 代表分钟
//s 代表秒
//S 代表毫秒
SimpleDateFormat sin = new SinpleDateFormat(“yyyy-MM-dd HH:mm:ss SSS”) //规范化输出的日期的格式
Carlendar 日历类别 常用于进行翻日历
Calender C = Calendar.getinstance（） //用于返回一个Calendar 对象
Add方法：在原日期上增加年/月/日 Set方法：直接设置年/月/日
//中级9.26
New FileInputStream（f）试图打开某个文件
Try catch 抛出异常问题 ：
文件存在顺序执行且不会执行catch中的代码
文件不存在：try中的代码会立刻终止
文件路径中的：FileNotFoundException 一般第一反应是path不存在
其中的printStackTrace用来判断位置
Catch中的Exception 也可以catch住FileFoundException的异常内容
解析异常ParseException
多异常捕捉方法：catch（FileNotFoundException|ParseException）
（注：instanceof 用于判断一个类是否是另一个类的实例）
异常的抛出过程中 当有finally修饰的内容部分无论是否抛出异常都会被执行
异常的处理要么用try-catch 要么用throws来进行抛出相应的异常项
一但try-catch住了就相当于处理完了这个异常的内容
FileNotFoundException FileInputStream（） File文件位置
面试题：throw和throws的区别
throws 出现在方法声明上，而throw通常都出现在方法体内。
2. throws 表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某个异常对象。
Finally中的返回值中有数值的时候会默认的返回finall中的代码 （会默认的取代try 和catch中的数值）
异常分类： 可查异常，运行时异常和错误3种 其中，运行时异常和错误又叫非可查异常
FileNotFoundException为可查的异常处理：不进行处理编译器不会让其进行通过
（要么往外抛，要么谁调用的问题，谁处理）
9.29
File inputstream 文件读取的io流
运行时异常：
除数不能为0异常:ArithmeticException
下标越界异常:ArrayIndexOutOfBoundsException
空指针异常:NullPointerException
运行时异常和非运行时异常的区别：error表示程序中的严重错误问题，大多数和编写者执行的操作无关，一般表示和java相关的java虚拟机的问题
运行时异常常常指的是程序本身可以处理的异常问题，运行时异常都是RuntimeException类和其子类的异常，常见的有空指针异常、下行越界异常、类转换异常、数据存储异常。运行时异常指的是虚拟机通常操作中可能遇到的异常，是一种常见的运行错误
运行时异常是不可查异常，不需要进行显式的捕捉
非运行时异常是可查异常，必须进行显式的捕捉，或者抛出 Error不捕获，因为此时表示程序直接无法运行，捕获没有任何意义
Throwable是类，Exception和Error都继承自该类别 因此在进行捕捉的时候可以通过Throwable进行捕获
9.30
创建文件的绝对路径和相对路径：getAbsulutePath();
Getpath （）//获取其中的相对路径 在eclipse中就是相当于项目目录位置
Isfile /是否是一个文件
File f = new File（） //括号中必须要有对应的路径问题
f.list //返回当前文件夹下的字符串数组的形式返回当前文件夹下的所有内容
f．listfile 表示返回当前文件下的子文件
输入流 inputstream outputStream 输入输出流 、
数据源可以是文件/数据库/网络或者是其他的程序
建立了一个文件的输入输出流可以将数据输出到JVM（Java虚拟机中）
输入流是一个抽象类，只能提供方法声明，不提供具体的方法的实现
FileInputStream 是InputStream的子类
输入流执行的是 read（all） 输出流执行的是 wirte（all）
相同点：都需要在最后执行后执行 f.close()进行关闭的数据流
在try中进行数据流的关闭会占用大量资源，因此会执行在finall中来进行数据流的关闭
toCharArrary（） //将字符串转换为字符数组
java中的汉字执行后都会变成JVM的形式
缓存流解决字符流和字节流的弊端：缓存在读取的时候会一次性多的数据读取到缓存中；写数据时候会先把数据写入到缓存区，知道缓存区满了一起写入到硬盘中去
字符流：每写一个字节都访问硬盘
立刻把数据写入到硬盘 flush() 方法
PrintWriter 缓存字符输出流， 可以一次写出一行数据
缓存字符输入流 BufferedReader 可以一次读取一行数据
DataInputStream 数据输入流 DataOutputStream 数据输出流
System.out 是常用的在控制台输出数据的 System.in 可以从控制台输入数据
Eg：Scanner s = new Scanner（System.in）
流——字节流/字符流——数据流/对象流/缓存流
..
数组的长度不用会产生浪费——因此产生了ArrayList （容器类的概念）
Heros.add()
10.2
Contain判断是否在容器中，判断是否为同一个对象，而不是name相同
Indexof判断对象在ArrayList中的位置；
toArray可以把一个ArrayList对象转换为数组
addALL把容器中的所有对象都添加进去。
ArrayList<E> 就是一种泛型
List<Hero > generaction = new ArrayList<Hero>(); //设置一个泛型
Java1.7提供了一种只需要书写前面的泛型名称即可的放肆
List<Hero> generacttion = new、 Arraylist<>（）； //泛型的简单书写方式
泛型类编写的目的是：编写的代码可以被不同类型的对象引用
List是一个接口，而ArrayList是List接口的一个实现类。ArrayList类继承并实现了List接口
所以List不能被构造，不能创建实例对象
迭代器处理遍历结合中的元素Iterator 迭代器
双向链表结构Deque，可以很方便的在头尾插入删除数据
二叉树 Node 类名 public Node leftNode//左子节点； public Node rightNode //右子节点
public Object value
java 实现冒泡排序：每一次都会确定一个最大的数值
HashMap 存储的——键值对 HashMap<String,String> a = new HashMap<>();
获取键值对通过get（） 函数获取 hash中的key是唯一的 是不可以重复的，相同的key指挥保留最后进行插入的数据
HashMap中的HashSet
HashSet 中的元素不允许重复 如： HashSet<String> names = new HashSet<String >()
PS：set中不提供get（）来获取指定位置的元素，所以遍历需要用到迭代器胡总恶化增强型的for循环
增强形for循环：适用于集合 Map和Collection （集合的两个主要接口）；Collection 又分别被List和Set（Hash中的Set和ArraryList中的方法）
Interator迭代器 是Java集合的顶层接口
注：Collection和Map之间没有关系，Collection是放一个一个对象的，Map 是放键值对的
常考的面试题：ArrayList 与 LinkedList的区别是面试常常会问到的考题
ArrayList 插入，删除数据慢 LinkedList， 插入，删除数据快
ArrayList是顺序结构，所以定位很快，指哪找哪。 就像电影院位置一样，有了电影票，一下就找到位置了。
LinkedList 是链表结构，就像手里的一串佛珠，要找出第99个佛珠，必须得一个一个的数过去，所以定位慢
Collection 类中的类方法有：reserve 、shuffle、 sort、swap（交换）
reserve集合中的翻转：Collections 是容器的工具类，容器的工具类如同Arrays是数组的工具类
Shuffle 混淆List数据的顺序
Sort 排序方法 swap交换 rotate （numbers，2） 向右滚动元素
线程安全化：synchronizedList
list中可以通过 对象名.get（） 来获取对应的数值 1000000d中的d代表方差
ArrayList有顺序 HashSet无顺序且HashSet的具体顺序，既不是按照插入顺序，也不是按照hashcode的顺序（其中不同的JVM执行的不一样）
创建一个List组合数据 通过add（9） //添加 数字9 来进行数据的添加
List类是ArrayList类的泛型等效类 ——
eg:List<Integer> number = new Arraylist<>();
List中的数据可以重复(ArrayList创建，通过ADD添加)
Set中的数据不能够重复 （两次add添加只会保留一个具体的数据）
重复判断标准是:首先看hashcode是否相同;如果hashcode不同，则认为是不同数据;如果hashcode相同，再比较equals，如果equals相同，则是相同数据，否则是不同数据.
（int）（Math.random()*10000） //四位数 random获得的默认的为0-1
Mathradom *100为0-99
PS：List是一个接口，而ArrayList是List接口的一个实现类。ArrayList类继承并实现了List接口。 List接口不能被构造，也就是我们说的不能创建实例对
HashMap和Hashtable 的区别：HashMap和Hashtable都实现了Map接口，
都是键值对保存数据的方式
区别1： HashMap可以存放 null；Hashtable不能存放null
区别2：HashMap不是线程安全的类 Hashtable是线程安全的类
Eg:形如：Hashtable<String,String> hahMap.put(123,null)
keySet()可以获取所有的key, values()可以获取所有的value
eg：Set<String> k = hashmap.keySet(); //k 和V为自己定义的量
Collection<String> v = hashmap.values();
扫一扫
838
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
