JAVA

快捷键：
alt+enter是自动修正代码
ctrl+y删除光标所在行
ctrl+d复制光标所在行
Ctrl+alt+L 格式化代码，即将代码对齐
Ctrl+/ 单行注释
Ctrl+shift+/ 选中代码进行多行注释
alt+shift+上下箭头，移动光标行
for(i=0;i<5;i++)可以打成 5.fori+回车
for(i=4;i>=1;i++)倒序，可以打成5.forr+回车

定义方法的格式：
修饰符+返回类型+方法名称(参数类型 参数名称，....){
}

方法的三种调用：(求什么，得到什么有返回值进行一大堆操作而已，没有进行计算和调用处给返回值)
1：单独调用， 方法名称(参数)； 例如sum(5,10);//没有返回值，有返回值适用
2：打印调用：System.out.println(方法名称(参数))；//有返回值适用
3：赋值调用：数据类型 变量名称=方法名称(参数)；System.out.println(变量名称)；//有返回值适用

方法三要素：
1：返回值类型
2：方法名称
3：参数列表

方法的重载：
多个方法名称一样，但参数列表不一样
优点，只需记住唯一一个方法，就可以实现类似的多个功能
注意：方法的类型要一样，参数一样，参数的类型可以不一样

数组初始化
动态初始化(指长度)：数据类型 [ ] 数组名称=new 数据类型[元素个数] //标准格式
静态初始化(指内容)：数据类型 [ ] 数组名称=new 数据类型[ ]{元素1，元素2，。。} //标准格式
省略格式 数据类型 [ ] 数组名称={元素1，元素2，。。}

动态初始化每个元素都会有一个默认初始值
整数类型 0
浮点类型 0.0
字符类型 ‘\u0000’
布尔类型 ture false
引用类型 null

Array.toString()类会把数组变成想要格式的字符串

类是属性和行为的集合
属性：是什么的特征描述信息
行为：事物能做什么
类是对一类事物的描述，是抽象的
对象是一类事物的实例，是具体的
类是对象的模板，对象是类的实体

成员变量(属性)
成员方法(行为)
注意，成员变量定义在类里面，方法外面
public static void 名称是方法
public void 名称 是成员方法
创建对象标准格式： 类名称 对象名=new 类名称()；

导包：import 包名称.类名称//如果和要调用的包处于同一个包下，可以省略导包语句不写，只有java.lang包下内容不需要导包语句

封装就是将一些细节信息隐藏起来，对于外界不可见，更加省心
封装分为1：方法
2：private，(定义不合法数值)在本类中可以随意使用，但是超出本类不能直接访问，应该使用到成员方法set //通常是设置数据
应该用void get获取数值用int
输出时候用 System.out.println(对象.get())
改变数值用对象.set(要改变的数值)

构造方法：格式 pubilc 所在类名称(参数类型 参数名称){
}
Student stu=new Student(); 其中Student()是类Student的构造方法
构造方法就是可以直接创建对象可以直接执行方法//创建对象然后(这里面填上有参数构造方法)
注意事项：没有返回值
构造方法的名称必须和所在的类名称完全相同，大小写也一样
没有void

标准的类
1：所有成员变量用private关键字修饰
2：为每一个成员变量编写一对get set
3编写一个无参数的构造方法
4：编写一个有参数的构造方法
快捷键 编写这些alt+insert

匿名对象格式 new 类名()
建议：确定只有一个对象，只需使用唯一一次

Random类
格式 Random r=new Random()；
int num=r.nextInt( );括号中内容表示范围 左闭右开

ArrayList集合
标准格式： ArrayList list =new ArrayList<>();
优点长度是可以随意变换的
集合中的所有元素，都是统一类
只能用引用类型，不能是基本类型
如果想用基本类型就要进行包装
基本类型 包装
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
注意事项：ArrayList集合来说，直接打印得到的不是地址值，而是内容，若内容为空，则得到是空的中括号[ ];
添加用 list.add()
获取用 list.get(index)
删除用 list.remove(index)
获取元素个数 list.size()
遍历集合用 System.out.println(list.get(i));

String
程序中所有双引号字符串，都是String类(就算没new)
字符串特点
1：字符串内容永不可变
2：因为永不可变，所有可以共享
3：字符串效果上相当于char [] 但是底层原理是byte []字节数组
字符串的三种构造方法
1：public String()//创建一个空白字符串，不含任何内容
2：public String(char[] array)//根据字符数组，来创建字符串内容
3：public String(Byte[] array)//根据字节数组，来创建字符串内容

字符串常量池，程序中直接写上的双引号字符串吗，就在字符常量池中
对于基本类型来说，==是进行数值的对比
对于引用类型来说 == 是进行地址的对比
如何进行内容比较用到public boolean equals(Object obj);即 str1.equals(str2);
equals具有对称性 即str1.equals(str2)和str2.equals(str1)一样
public booleanequalsIgnoreCase(String str)对比内容但是不区分大小写
通常字母写在前->"abc".equals(str1)

String 的获取：
String int length() //获取字符串长度
public String concat(String str) //将当前字符串和参数字符串拼接成为返回值新的字符串
public char charAt (index) //获取指定索引位置的单个字符，
public int indexof (String str)//查找参数字符串在本字符串当中首次出现索引位置，如果没有返回-1

String的截取：
public String substring(int index)//截取从参数的位置一直到字符末尾，返回新字符串
pubilc String substring (int begin ，int end)//截取从begin开始一直到end结束，中间的字符，[ )左闭右开
String的转换：
public char[] toCharArray();可以单个用字符串中某个字符//也是将String转化为数组
public byte[] getBytes();单个字符的字节数；
public String replace(CharSequence oldString ,CharSequence newString);改变字符串中某些字符
String的分割：
public String[] split(String regex);根据参数规则，把字符串分成若干部分
注意："."在参数中要写成\.

static :
没有用到static，要创建对象才可以使用，通过对象进行调用
有用到static,不用创建对象直接使用，【通过类进行调用】//根据类名称访问静态成员变量的时候，全程和对象就没有关系
注意：静态方法不能调用非静态变量

静态代码块： static{
}
静态内容优先于非静态内容

第一次用到类时，静态代码块执行唯一的一次；

public static void toString(数组)；将参数数组变成字符串(按照默认格式：[元素1，元素2，元素3.。。。])
public static void sort(数组)；按照默认升序(从小到大)对数组元素进行排//必须是一个数组才能用

Math：
Math.abs() 求绝对值
Math.ceil() 向上取整(正方向)
Math.floor() 向下取整

Math.round() 四舍五入

继承
子类 extends 父类
重名
1：等号左边是谁就优先用谁
2：方法属于谁就优先用谁
3：方法重名创建对象是谁则优先用谁
//无论成员变量还成员方法都是向上找
对于子类变量和子类局部变量重名以及父类变量重名问题
子类局部变量 直接用
子类变量 this.变量
父类变量 super.变量

重写(覆盖重写)//发生在继承中
覆盖重写：方法名称一样，参数列表【也一样】
重载： 方法名称一样，参数列表【不一样】
@Override是用于检查方法是否是重写，不是重写会报错，位置在方法前面
子类返回值类型必须小于或等于父类返回值类型
Object类是祖宗类最大
例如父类 public Object method() 子类 public String method()正确
子类权限修饰符必须大于或等于父类的权限修饰符(权限修饰符在上面就是public)

public >protected>(default)//什么都不写>private

继承中构造方法：
子类调用父类构造方法用super()
1：子类构造方法中有一个默认隐含super()；所有一定是先调用父类构造方法在调用子类构造方法
2：不能调用多个构造方法只能有一个

3：只有子类构造方法才能调用父类构造方法

Super：
1：在子类的成员方法中，访问父类的成员变量 super.变量
2：在子类的成员方法中，访问父类的成员方法 super.method()
3：在子类的构造方法中，访问父类的构造方法/./隐藏了super()

this：
1：在本类的成员方法中，访问本类的成员方法；
2: 在本类的成员方法中，访问本类的另外一个成员方法；
3：在本类的构造方法总，访问本类的另外一个构造方法； //this()；

抽象 类：(如果父类当中不确定如何进行{}方法体的实现，那么这就应该是一个抽象方法)
格式：在类public后加上abstract；如果想用抽象方法也是在public后加上abstract 然后去掉括号{}加上；
1：不能创建对象，如果想要创建对象则需要借助子类 (子类中需要覆盖重写父类中【所有】方法)，
(如果父类方法中没有，则向上爷爷类访问)去掉abstract，加上{}

===================================================
接口：多个类的公共示范
接口是一种引用数据类型，最重要的内容就是其中的抽象方法
格式：public interface 接口名称{
}
使用：不能直接使用，必须有一个“实现类”来“实现”该接口；//和抽象类差不多
实现类格式：public class 实现类名称 implements 接口名称{
}
接口的默认方法 public default/static 返回值类型 方法名称(参数列表){
}//用于解决接口升级的问题(在接口中添加新的方法避免类中重写覆盖重写)
接口中也有static 即将abstract或者default改成static，变成和普通方法一样，实现类不需要覆盖重写方法；
私有类private ：
1：普通私有方法，解决多个默认方法之间重复代码
格式：private 返回值类型 方法名称(参数列表){
}
2：静态私有方法，解决多个静态方法之间重复代码 //接口自己可以调用，实现类调用不了
接口中也可以定义“成员变量”，但是必须用public static final三个关键字修饰，效果上看就是常量
注意，通常给常量大写，遇到多个单词用下划线"_",而且必须赋值
注意：
1：接口没有静态代码块
2：接口没有构造方法
3：一个类有唯一一个父类，但是一个类可以有多个接口
4：如果实现类中没有覆盖重写所有的抽象方法，那么实现类必须是一个抽象类(如果是有冲突的默认方法，类中必须重写)
5：对于接口当中重复的默认方法，(方法体不一样)，则需对重复的多个发放都要进行重写
一个类如果父类当中的方法，和接口当中的默认方法产生冲突，优先用父类当中的方法
6：接口与接口中的多继承

多态性(一个对象有多个身份)
格式：父类名称 对象名 =new 子类名称()；《==》 接口类名称 对象名=new 实现类名称()；
访问成员变量方式
1：直接访问，等号左边是谁就是谁，没有就向上找
2：间接访问，通过成员方法访问，该方法属于谁就是用谁//如果是覆盖重写，被谁覆盖重写该方法就属于谁
访问成员方法：看new谁就先用谁
口诀：编译看左边，运行看右边

用多态性的好处：无论右边new的时候换成那个子类对象，等号左边调用方法都不会改变

对象的向上转型：(要确保转型是安全的，从小范围转向大范围)
格式：父类名称 对象名=new 子类名称()；
含义：右侧创建一个子类对象，把他当做父类来看待使用
弊端：一旦向上转型为父类，那么就无法调用子类原本特有的方法

对象的向下转型：(还原的一个过程，前提是已经向上转型)
格式：子类名称 子类对象名=(子类名称)父类对象；
含义：将父类对象，【还原】为本来的子类对象
注意事项：如果是猫转型为动物，然后想向下转型为狗，就会报错。
可以用instanceof来确定到底向下转型是猫还是狗；

final:(最终不可变)
1：可以用来修饰一个类
格式： public final class 类名称{
} //太监类，没有儿子
2：可以用来修饰一个方法
修饰符 final 返回值类型 方法名称(参数列表){
方法体
}//不能被覆盖重写
3：可以用来修饰局部变量
4：可以用来修饰成员变量//一开始就要手动赋值
赋值：1直接赋值2通过构造方法赋值也是对的

注意事项：抽象类和final不能同时使用，因为矛盾

权限修饰符(方法对成员变量的调用看看可不可以调用，没有关系的用new 调用)
public >protected>(default)>private
1：同一类 可以 可以 可以 可以
2：同一个包 可以 可以 可以 不可以
3：不同包子类 可以 可以 不可以 不可以

4：不同包非子类 可以 不可以 不可以 不可以

内部类：(一个事物内部包含另外一个事物)
例如 身体和心脏 汽车和发动机
格式：修饰符 class 外部类名称{
修饰符 class 内部类名称{
//...
}
}
注意：内用外的权限修饰符可以随意使用
外用内需要内部类对象

如何使用成员内部类
1：间接方法 在外部类的方法当中，使用内部类，如何main只是调用外部类的方法
2：直接方法 外部类名称.内部类名称 对象名=new 外部类名称(). new 内部类名称()；
遇到重名：
内部类方法中调用外部类的成员变量 Out.this.num
局部内部类：位置在外部类方法中的类// 【局部】在所属的方法中才能使用它，出了方法就不能使用了
注意：要用该局部内部类，就要在方法内调出局部内部类方法才能使用
格式：修饰符 class 外部类名称{
修饰符 返回值类型 外部类方法名称{
class 局部内部类名称{
///.......
}
}

}
权限修饰符
外部类:public /(default)
成员内部类：public /protected/(default)/private
局部内部类：(default)
final
局部内部类中，如果希望访问所在方法的局部变量，那么这个局部变量必须是有效的final

匿名内部类(省略类名称，没有省略对象名称，也可以省略对象名称)：如果接口的实现类(或者父类的子类)只需使用唯一一次，
那么这种情况下就可以省略该实现类(子类)的定义，而改为匿名内部类
如果想要多个对象名，则只能用之前学的实现类
格式：
接口名称 对象名 =new 接口名称(){
覆盖重写所有抽象方法(可以是多个抽象方法)
}；
注意：最后还要调用一下
更简化的匿名内部类匿名对象：
hero.setSkill(new Skill() {
@Override
public void use() {
System.out.println("吧啦啦啦能量");
}
});

equal
==比较运算符，返回的是一个布尔值 true false
引用数据类型：比较的是两个对象的地址
object类的equals方法比较的是两个对象的地址值，没有意义，
所以我们要重写equals方法，比较两个对象的属性-》用到向下转型

Date类：
java.util.Date:表示时间和日期的类
表示特定的瞬间，精确到毫秒(1/1000)s
时间原点：1970 年 1 月 1 日 00:00:00
System.currentTimeMillis() 获取当前系统一共到1970年一月一日0.0.0经历了多少毫秒
Date()空参数构造方法获取当前系统日期和时间
Date(Long date)：传递毫秒值，把毫秒值转换为Date日期
Long getTime()；把日期转换为毫秒

DateForamt类：(是个有抽象类)
String format (Date date)按照指定的模式，把date日期，格式转化为符合模式的字符串使用前要创建对象
Date parse(String source)把符合模式的字符串，解析为date日期使用前要创建对象 thorws 抛出异常
->SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
构造方法：
SimpleDateFormat(String pattern)
y 年
M 月
d 日
H 时
m 分
s 秒

Calendar类：(日历)抽象类
c.set(Calendar.YEAR, 999);设置时间
同时设置年月日c.get(年，月，日)
c.add(Calendar.YEAR,20);增加20年，负数表示减少20年
c.get(Calendar.YEAR) 返回当前系统的年日期
c.getTime();返回一个日期；

System类：
System.currentTimeMillis();获取毫秒值
System.arraycopy(src , srcPos , dest , destPos , length)
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。

复习String类：创建后不可改变
StringBuilder类(可以改变)：底层缓存区，提高操作效率 容量是16
在内存中始终是一个数组，占用内存少，效率高
如果超出容量16可以自动扩容32
构造方法：
1：StringBuilder()初始字符串容量为16个字符
2：StringBulider(String str)初始化为指定的字符串内容

常用方法：
1：append()，添加任意数据
扩展：链式编程 -> a.append(123).append("abc").append()
2：转化成String：toString
String转化成StringBuilder用构造方法(有参数)

包装类：使用一个类，把基本数据类型的数据包装起来，在类中定义一些方法，这个类就叫做包装类
基本类型 对应的包装类(位于java.lang包中)
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
装箱：从基本数据类型转换为对应包装类的对象
Integer a=new Interger()；
Interger b= Interger.valueOf()；
拆箱: 从包装类对象转换为对应的基本数据类型
a.intValue()
自动拆箱和装箱(jdk1.5之后出现的功能)
integer a=1；

基本类型->字符串(String)
1：基本数据的值+“” 最简单方法
2：Integer。toString(参数)
3：String。valueOf(参数)
字符串->基本类型
Integer。parseInt()

collection类(没有带索引)
方法:
1:public boolean add(E e);
2:public void clear();//清除所有数据
3:public boolean remove (E e);
4:public boolean contains(E e);//是否包含
5:public boolean isEmpty();
6:public int size();
7:public Object[] toArray();//把集合中的元素，存储到数组---》就是集合变成数组

迭代器(对集合进行遍历)
使用步骤1：使用集合中的方法iterator()获取迭代器的实现对象，使用iterator接口接收(多态)
2：使用iterator接口中的方法hasNext判断还有没有下一个元素
3：使用iterator接口中的方法next去除集合的下一个元素

增强for循环(foreach)用来遍历集合，数组
格式：for(集合/数组的数据类型 变量名：集合名/数组名){

sout(变量名)
}
优点： 比迭代器好用

泛型：(不知道用什么类型的时候用)
E：表示未知类型
创建集合对象时，就会确定数据类型
缺点:用泛型在调用一些东西时候可能会引发一些错误；
好处：避免了类型转换的麻烦
方法：在修饰符和返回值之间
格式：修饰符 <泛型> 返回值类型 方法名称(参数列表(使用泛型)){
//...
}
传递什么类型参数，返回值就是什么类型
在实现类中含有泛型接口public class InterfaceImpl implements Myinterface
String就是相当于返回值类型
泛型的通配符 <?>//不知道使用什么类型来接收的时候用
只接收数据，不能往集合中存储数据->你给我什么类型我都可以接收，通常在方法中使用
使用方法：1 不能创建对象使用 只能作为方法的参数使用
泛型的上限限定： ？extends E
泛型的下限限定：？ super E

List接口特点：
1；有序的集合，
2：有索引
3：运行存储重复元素

遍历现在学那么多通常这样
1：for(){
get(i)；
sout
}
2：迭代器遍历
Arraylist查询快，增删慢
Linkdelist 增删快 implents List
vector 也是一个老祖宗(单线程)

set接口
特点1：不允许包含重复元素
2：没有带索引(就不能用普通的for循环遍历)
hashSet implents Set
特点1：不允许包含重复元素
2：没有带索引(就不能用普通的for循环遍历)
3：无序的集合，存储和取出的元素顺序有可能不一致，
4：底层是一个哈希表结构，查询非常快
哈希值：是一个十进制的整数，由系统随机给出(就是对象的地址值，是一个逻辑地址，是模拟出来的地址，不是数据实际的存储的物理值)
@4554617c是1163157884十六进制
@74a14482是1956725890十六进制
cn.itcast.day23.Demo03Set.Main2haxizhi@4554617c
cn.itcast.day23.Demo03Set.Main2haxizhi@74a14482
jdk1.8版本之前：哈希表=数组+链表
jdk1.8版本之后：哈希表=数组+链表 如果链表超过了八位就会把链表转换为红黑树
哈希表=数组+红黑树(提高查询速度)
数组：把元素进行分组(相同哈希值为一组)
链表/红黑树：把相同哈希值的元素连接到一起
自定义类的HasSet接口，要添加equals和

Q.E.D.