变量的命名
String obj="obj"; 需要封号结尾 大小写敏感
int age=17; 整型
float float height=175.2f 单精度浮点型 f结尾
double 双精度浮点型
char char a='A' 储存单个字符 使用单引号
boolean 布尔型
自动类型转换
double avg1=78.5; 目标类型能与源类型兼容 double int 都为数字 目标类型大于源类型 double 8字节 int4字节
int rise=5;
double avg2=avg1+rise;
强制类型转换
double heightAvg1=176.8;
int heightAvg2=(int)heightAvg1; //176 将小数位截取 可能造成数据丢失
常量的定义
final char BOY='男';
final char GIRL='女';
异或
a^b a和b有且仅有一个为true
输出
System.out.println("aa"); 会换行
System.out.print("aa"); 不换行
数组
int[ ] scores ={1,2,3,4}; int scores[ ] ={1,2,3,4}; 定义整型数组
int[] scores=new int[5]; 声明数组 scores[0]=1; 数组赋值 等价于 int[] scores=new int[ ]{1} 等价于int[] scores={1}
二维数组
int[][] num =new init[2][3]; int[][] num ={{1,2,3},{4,5,6}};
foreach循环
for ( int value : arr ) {
System.out.println(score);
}
方法
public void print() { 访问修饰符 返回值类型 方法名 void：不返回任何值
System.out.println("Hello World");
}
方法的重载
如果同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不同的方法，则称为方法的重载
调用时传入不同的参数就可以调用不同的方法
类成员变量和局部变量
成员变量 在类中定义，在本类方法 或者与本类有关的方法中可用 有初始值
局部变量 在方法中定义 只在方法中可用 同方法中 不能有重名局部变量 不同方法中 可以重名
构造方法
与类名同名 没有返回值 在实例化的时候调用 可以不写 不写的话系统自动生成无参构造方法
有参的构造方法和无参的构造方法可以共存 自定义有参构造方法之后 系统就不会自动生成无参构造方法
static
静态属性 被类的所有对象所共享 通过类名调用/更改 或者实例化后通过实例调用/更改
静态方法 可以直接调用静态属性和别的静态方法 需要通过实例调用普通方法和普通属性 普通方法中可以直接调用静态方法和属性 或者普通方法和属性
静态初始化块
静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。
程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。
包管理
定义包 通过源文件的第一行 package 来定义包 通过import来引入包 import com.hid.demo.* 引入demo下的所有程序
访问修饰符
private 只能在本类中可访问 私有
默认 本类和同包中可访问
protected 本类 同包 和子类中可访问
public 公有的
内部类
可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
内部类的方法可以直接访问外部类的所有数据，包括私有的数据
内部类需要通过外部类的实例化对象来构造 不能直接new
变量名相同 内部类默认访问自己的变量 可以通过Outer.this.a 来访问外部类的a
静态内部类
静态内部类不能直接访问外部类的非静态成员，但可以通过 外部类的实例来访问
静态内部类可以直接创建 内部类 对象名= new 内部类();
外部类的静态属性和内部类成员名称相同，可以通过Outer.name来访问 不相同的话可以直接通过name访问
方法内部类
方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。
由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。 class Inner{ }
继承
class Child extends Parent{ }
子类方法的重写 返回值类型 方法名 参数类型和个数 都要与父类方法相同
初始化顺序 父类的属性初始化 父类构造方法 子类属性初始化 子类构造方法
final
修饰类 则该类不允许被继承
修饰方法 则方法不能被重写
修饰属性 该属性不会进行隐式初始化 初始化必须赋值或者构造方法中赋值 两者取一
修饰变量 则该变量只能赋值一次 类中可以在构造方法中赋值 方法中的局部变量添加final之后 即为常量
super
在子类中 通过super可以访问父类的属性和方法
子类的构造过程必须调用父类的构造方法 即super( )；
如果未显示调用super() 则系统默认调用父类无参构造方法
显示调用父类构造方法 需要在子类构造方法的第一行 即super()需要在第一行
若子类未显示调用父类的构造方法 父类中没有无参构造方法 则编译报错
Object类
object类是所有类的父类 若类未使用extends表明继承自某一个类 则默认继承Object类
toString()方法
obj.toString()
返回对象的哈希code码（对象的地址字符串）
子类的toString方法可以通过idea编译工具code/Generate/toString()改写
equals()方法
obj.equals(obj2) 返回布尔值
比较对象的引用是否指向同一个内存地址
通过idea编译工具code/Generate/equals()改写 比较两个对象的值是否相同
多态
Parent variable = new Child();
若子类改写方法 则调用改写的方法 若未改写则调用继承的方法 不能调用子类独有的方法
使用父类的引用 调用父类中的方法 如果方法被重写 则调用重写的方法
引用类型转换
Dog dog =new Dog();
Animal animal =dog; 自动类型提升 向上类型转换
Dog dog2=animal; 向下类型转换 无法编译 Dog dog2=(Dog)animal; 强制类型转换
if( animal instanceof Dog){ Dog dog2=(Dog)animal } 判断是否可以进行类型转换
抽象类
使用abstract修饰符 则为抽象类；
abstract定义抽象方法 只有声明 不需要实践
包含抽象方法的类是抽象类
抽象类中可以包含普通方法 可以没有抽象方法
抽象类不能直接创建 可以定义引用变量
应用场景
父类只知道其子类应该包含怎样的方法 而无法准确知道子类如何实现这些方法，则可以使用抽象类
从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免子类设计的随意性
限制规定子类必须实现某些方法，但不关注细节
接口
修饰符一般为public 不能使用provate和protected；
如果未显示添加 abstract修饰符 系统会自动添加 接口可以继承多个父接口
接口中的属性是常量 即使定义时不加，系统也会自动添加 public static final修饰符
接口中的方法都是抽象方法 如果没有 系统会自动添加 public abstract
public interface 接口名 [extends 父接口1，父接口2...]{ 0到多个常量定义，0到多个抽象方法的定义 }
使用接口
实现接口使用implements关键字 java中一个类只能继承一个父类 可以通过多个接口做补充
继承父类实现接口
修饰符 class 类名 extends 父类 implements 接口1，接口2...{ 类体部分 如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法 }
继承父类 父类需要在实现接口之前 extends在前
Throwable
JAVA中所有不正常类都继承于Throwable
Error 系统错误 （内存溢出、虚拟机异常）
Exception 系统异常（编码，环境，用户操作输入出现问题）
RuntimeException 运行时异常（非检查异常） 有JAVA虚拟机自动抛出自动捕获
检查异常 需要手动添加捕获和处理语句
try-catch-finally
如果try-catch-finall语句块中没有return语句 则会调用语句块之外的return语句；
finally语句在在try-catch语句执行完毕 返回之前 执行
异常抛出
thorw 抛出异常
throws 声明要抛出的异常种类 public void 方法名（参数列表）throws 异常列表 { 调用会抛出异常的方法或者 throw new Exception(); }
如果是抛出新的异常 就要使用throws声明将要抛出的异常可以使用逗号分隔多个异常
自定义异常
public class theException extends Exception{
public theException(){ }
public theException(String message){
super(message);
}
}
String
String a="imooc"; String b="imooc"; String c=new String("imooc");
String类是不可变的 重新赋值的话只是额外创建一个对象保存新字符串 然后当前变量指向这个新对象
a为一个变量 存放了对字符串变量 imooc 的引用 ； a和b中imooc为常量字符串 多次编译只创建一个对象 所以a==b为true
a==c 由于内存地址是不同的 所以为false 可以通过 equals（）来比较内容是否相同
str.length();
str.indexOf(); 查找字符串 没有的话返回-1
str.split(" "); 使用空格拆分字符串返回数组
str.substring(3,7); 获取3到7下标的字符
str.trim(); 返回去除了前后空格的字符串
str.toLowerCase() toUpperCase()
str.charAt() 获取指定位置的字符
str.getBytes() 将字符串转为byte数组
StringBuilder 非线程安全
可变的 不会产生额外的无引用对象
strbuilder.append() 追加到当前str末尾
strbuilder.insert(位置，参数) 将内容插入到指定位置
strbuilder.toString（） 转为String对象
length（）
StringBuffer 线程安全
可变的 不会产生额外的无引用对象
基本类型和包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
包装类提供了两大方法
将本类型和其他基本类型进行转换的方法
将字符串和本类型及包装类互相转换的方法
包装类的常用方法
基本类型转包装类
// 定义double类型变量
double a = 91.5;
// 手动装箱
Double b = new Double(a);
// 自动装箱
Double c = a;
包装类转基本类
// 定义一个Double包装类对象，值为8
Double d = new Double(87.0);
// 手动拆箱
double e = d.doubleValue() ;
// 自动拆箱
double f = d ;
基本类型和字符串的转换
基本类转字符串
int c=10;
String str=Integer.toString(c);
String str1=String.valueOf(c);
String str3=c+" "; 基本类型加空字符串
字符串转基本类型
String str="9";
int d=Integet.parseInt(str);
int e=Integet.valueOf(str);
Date和SimpleDateFormat
将当前时间转换为指定格式的文本
需要使用到 java.text.SimpleDateFormat和java.util.Date包
Date d=new Date();
SimpleDateFormat sd1=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
sd1.format(d);
将字符串转换为日期
String d = "2014-6-1 21:05:36";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date=sdf.parse(d);
使用parse（）可能会出现转换异常 需要异常处理 需要引入 java.text.ParseException包
Calendar类
抽象类 （推荐使用Calendar进行日期和时间的处理）
需要引入java.util.Calendar包
Calendar c=Calendar.getInstance(); 获取Calendar对象
int year=c.get(Calendar.Year); 获取年
int month=c.get(Calendar.Month)+1; 获取月份 0表示1月
int dat=c.get(Calendar.DAY_OF_MONTH); 日期
int hour =c.get(Calendar.HOUR_OF_DAY); 小时
int minute =c.get(Calendar.MINUTE); 分钟
int second=c.get(Calendar.SECOND); 秒
Date date=c.getTime(); 获取Date对象（将Calendar转换为Date对象）
Long time=c.getTimeInMillis() ; 获取当前毫秒数
Math
Math类中都是静态方法 直接通过 Math.方法 来调用
double a =12.23;
int b=(int) a; 强制转换 去小数位
Math.round() 四舍五入
Math.floor() 下取整
Math.ceil() 上取整
Math.random() 返回0-1的随机数
泛型
<类型> 泛型需要是引用类型 不能为基本类型 如果是基本类型需要填入基本类型的包装类
规定集合中能存放什么类型的数据 （可放入当前类型的子类型）
Collection Map
JAVA集合框架的两个根接口
Collection 存储一个个独立的对象
Collection的子接口： List（有序可重复） 、Queue（有序可重复） 、Set（无序不可重复）
List的实现类 （里面元素是有序可重复的）
ArrayList 数组序列
size() 获取长度 add( [index],obj) 添加内容 get（ind） 获取内容 addAll([index],list) addAll中 要使用 将数组转为List
set(index,list) 修改List remove(index || obj) 删除List removeAll(Arrays.asList(arr)); 删除全部
contains(val) 判断是否含有 返回bool值 原理：使用eauals（）来判断List数组和val的引用是否相同 可在实例val的类中改写equals方法
containsAll(Arrays.asList(arr)); 判断是否含有 indexOf(obj); 获取第一次出现的索引值 使用eauals（）判断 没有则返回-1
lastIndexOf() 返回最后一次出现的索引值
System.out.println("通过Iterator迭代器来遍历");
Iterator it=coursesToSelect.iterator();
while(it.hasNext()){
Course crt= (Course) it.next();
System.out.println(crt.getName());
}
Queue的实现类（也是List的实现类） LinkedList 链表
Set的实现类（无序不可重复）
HashSet 哈希集
可以添加null 空对象，没有get（）获取内容的方法，其余和ArrayList相同
contains(val)方法 先通过hashCode比较 再通过equals比较
Map存储的是一个个键值对
HashMap 哈希表 Map的实现类 无序的
get(key) 获取值 put(key,value) 添加值/修改值 size() 数量 keySet() 返回Map中所有key的Set集合
entrySet() 返回Map中所有的键值对 获取键值对后通过entry.getKey() entry.getValue() 来获取具体值
containsKey() 判断是否包含某个key值 （通过equals比较） containsValue 判断是否包含某个value值
Collections.sort()
为字符串排序 0-9=>A-Z=>a-z 第一个相同则比较第二个 以此类推
Comparable 默认比较规则（可比较的） 当一个类实现了Comparable接口 就要实现接口的compareTo()方法 a.compareTo(b)>0 a比b大
实现了compareTo()方法后 可以直接通过Comparable.sort()比较
Comparator 临时比较规则（比较工具接口） 其实现类需要实现Compare()方法 a.compareTo(b)>0 a比b大
实现Compare()方法后 通过 Comparable.sort (list，实现类) 来比较