Java基础
分为以下几个部分：
1、入门，HelloWorld
2、面向对象
3、变量
什么是变量：用来命名一个数据的标识符
-
变量的基本类型
变量有8种基本的数据类型
- 整型4种：byte、short、int、long，分别对应1、2、4、8个字节。
- 字符型1种：char，2个字节，用单引号表示，双引号表示字符串。
- 浮点型2种：float（4个字节）、double（8个字节）
- 布尔型1种：boolean，长度为1位
-
String类型
不是基本的数据类型，是Immutable（不可变类型），一旦创建就不能够被改变。
4、操作符
+、-、*、/、%、++、--
5、控制流程
if-else
-
switch
- 可以用byte、short、int、char、String、enum
- 每个表达式结束，都应该有一个break
- String是在1.7开始支持的，编译后是把String转化成hash值，其实还是整数类型。
while
for
-
continue
继续下一次循环
-
break
结束循环
-
结束外部循环
-
break结束当前循环
public class HelloWorld { public static void main(String[] args) { //打印单数 for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { System.out.println(i+":"+j); if(0==j%2) break; //如果是双数，结束当前循环 } } } } -
使用Boolean变量结束外部循环
public class HelloWorld { public static void main(String[] args) { boolean breakout = false; //是否终止外部循环的标记 for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { System.out.println(i + ":" + j); if (0 == j % 2) { breakout = true; //终止外部循环的标记设置为true break; } } if (breakout) //判断是否终止外部循环 break; } } }
-
使用标签结束外部循环
public class HelloWorld { public static void main(String[] args) { //打印单数 outloop: //outloop这个标示是可以自定义的比如outloop1,ol2,out5 for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { System.out.println(i+":"+j); if(0==j%2) break outloop; //如果是双数，结束外部循环 } } } }
-
6、数组
数组的特征：固定长度、相同类型
创建数组
初始化数组
-
排序
-
选择排序
把第一位和其他所有的位进行比较，只要比第一位小的，就换到第一个位置来，比较完后，第一位就是最小的。然后再从第二位和剩余的其他所有位进行比较，只要比第二位小，就换到第二个位置来，比较完后，第二位就是第二小的，以此类推。
-
冒泡排序
第一步：从第一步开始，把相邻的两位进行比较
如果发现前面的比后面的大，就把大的数据交换在后面，循环比较完毕后，最后一位就是最大的
第二步：再来一次，只不过不用比较最后一位
以此类推。
-
-
复制数组
System.arraycopy(src, srcPos, dest, destPos, length)
src: 源数组
srcPos: 从源数组复制数据的起始位置
dest: 目标数组
destPos: 复制到目标数组的起始位置
length: 复制的长度 二维数组
-
Arrays工具类，可以进行排序、查找、复制、填充等功能。
Arrays工具类.png
7、类和对象
引用
继承
-
方法重载
overload，指的是方法名一样，但是参数类型不一样，要和方法重写（override）区分开。
-
可变数量的参数
示例：public void attack(Hero ...heros)
构造器
-
this
- 代表当前对象
- 通过this访问属性
- 通过this调用其他的构造方法
-
类修饰符
那么什么情况该用什么修饰符呢？
从作用域来看，public能够使用所有的情况。 但是大家在工作的时候，又不会真正全部都使用public,那么到底什么情况该用什么修饰符呢？- 属性通常使用private封装起来
- 方法一般使用public用于被调用
- 会被子类继承的方法，通常使用protected
- package用的不多，一般新手会用package,因为还不知道有修饰符这个东西
再就是作用范围最小原则
简单说，能用private就用private，不行就放大一级，用package,再不行就用protected，最后用public。 这样就能把数据尽量的封装起来，没有必要露出来的，就不用露出来了.
类修饰符.png -
类属性
什么是类属性：当一个属性被static修饰的时候，就叫做类属性，又称静态属性。一个静态属性，所有的对象，都共享一个值。
什么是对象属性：实例属性，非静态属性
-
访问类属性：2种方法
对象.类属性
类.类属性
-
类方法
- 类方法：静态方法
- 对象方法：实例方法，非静态方法
- 访问一个对象方法，必须建立在有一个对象的前提的基础上；访问类方法，不需要对象的存在，直接就访问
-
单例模式
- 单例模式3要素：1、构造方法私有化，2、静态属性指向实例，3、供外部调用的方法，返回第2步的静态属性。
- 饿汉式
- 懒汉式
-
枚举
什么是枚举：是一种特殊的类，使用枚举可以很方便的定义常量，其关键字是enum。
-
实例：比如设计一个枚举类型季节，里面有4种常量。
public enum Season{ SPRING,SUMMER,AUTUMN,WINTER } 一个常用的场合就是switch语句中，使用枚举来进行判断。
-
借助增强for循环可以遍历一个枚举有哪些常量
public class TestEnum{ public static void main(String[] args){ for (Season s : Season.values()) { System.out.println(s); } } }
8、接口与继承
8.1、接口
单继承、多实现
8.2、对象转型
-
什么时候需要对象转型：引用类型和对象类型不一致的情况下，才需要进行类型转换。
引用类型和对象类型.png
向上转型：子类转父类
向下转型：父类转子类
instanceof
8.3、重写
- 关键字：ovverride，覆盖
- 注解标识：@override
8.4、多态
-
操作符的多态
+：既能标识是运算符，也能表示是字符串拼接
-
类的多态，需要满足如下条件：
- 父类（接口）引用指向子类对象
- 被调用的方法有重写
8.5、隐藏
与重写类型，方法的重写是子类覆盖父类的对象方法；隐藏，就是子类覆盖父类的类方法。
8.6、super
显示调用父类的属性和方法。
8.7、Object类
- Object是所有类的父类
- 它有哪些方法：
- toString()
- finalize()，当一个对象没有任何引用的时候，它满足垃圾回收的条件，当它被垃圾回收的时候，它的finalize方法就会被调用，不是由开发人员主动调用的，是由JVM虚拟机调用的。
- equals()，用于判断两个对象的内容是否相同。
- ==，不是Object的方法，用户判断两个引用，是否指向了同一个对象。
- hashCode()，返回一个对象的hash值
8.8、final
-
修饰类
被final修饰的类，不能被继承。
-
修饰方法
被final修饰的方法，在其子类中，该方法不能被重写。
-
修饰基本类型的变量
表示该变量，只有一次赋值的机会。
8.9、抽象类
- 定义：在类中声明了一个方法，这个方法没有方法体，是一个空方法，这样的方法就是抽象方法，使用修饰符abstract，当一个类有抽象方法的时候，该类必须被声明为抽象类。
- 抽象类可以没有抽象方法，一旦一个类被声明为抽象类，就不能被直接实例化。
- 抽象类与接口的区别
- 子类只能继承一个抽象类，不能继承多个，子类可以实现多个接口
- 抽象类可以定义public/protected/package/private、静态/非静态属性，final/非final属性，但是在接口中声明的属性，只能是public、静态、final的，即使没有显示的声明。
8.10、内部类
-
非静态内部类
- 语法：new 外部类().new 内部类()
- 可以访问外部类的private实例属性
-
静态内部类
- 语法：new 外部类.静态内部类()
- 不可以访问外部类的实例属性和方法
- 可以访问外部类的私有静态成员
-
匿名类
声明一个类的同时，实例化它，只是这个类没有命名而已。
public static void main(String[] args) { ADHero adh=new ADHero(); //通过打印adh，可以看到adh这个对象属于ADHero类 adh.attack(); System.out.println(adh); // 匿名内部类 Hero h = new Hero(){ //当场实现attack方法 public void attack() { System.out.println("新的进攻手段"); } }; h.attack(); //通过打印h，可以看到h这个对象属于Hero$1这么一个系统自动分配的类名 System.out.println(h); } -
本地类
可以理解成是有名字的匿名类
public static void main(String[] args) { //与匿名类的区别在于，本地类有了自定义的类名 class SomeHero extends Hero{ public void attack() { System.out.println( name+ " 新的进攻手段"); } } SomeHero h =new SomeHero(); h.name ="地卜师"; h.attack(); }
8.11、默认方法
- JDK1.8的新特性，接口也可以提供具体方法了
- 为什么会有默认方法：引入默认方法之后，不需要做任何改动，并且还能得到默认方法，通过这种手段，就能很好的扩展新的类，不影响原来的类。
8.12、UML图
9、数字与字符串
9.1、封装类
- 又叫包装类，所有的基本类型，都有对应的包装类。
- 如int，对应的是Integer
9.2、Number类
- 数字封装类有
Byte,Short,Integer,Long,Float,Double
这些类都是抽象类Number的子类。
-
基本类型转封装类型
int num = 5; // 基本类型转换成封装类型 Integer it = new Integer(i);
-
封装类型转基本类型
int num = 5; // 基本类型转换成封装类型 Integer it = new Integer(i); // 封装类型转换成基本类型 int num2 = it.intValue();
9.3、自动装箱
不需要调用构造方法，通过“=”符号，自动把基本类型转换成包装类型，就叫装箱。
public class TestNumber {
public static void main(String[] args) {
int i = 5;
//基本类型转换成封装类型
Integer it = new Integer(i);
//自动转换就叫装箱
Integer it2 = i;
}
}
9.4、自动拆箱
不需要调用Integer的intValue方法，通过=就自动转换成int类型，就叫拆箱。
public class TestNumber {
public static void main(String[] args) {
int i = 5;
Integer it = new Integer(i);
//封装类型转换成基本类型
int i2 = it.intValue();
//自动转换就叫拆箱
int i3 = it;
}
}
9.5、字符串转换
-
数字转字符串
使用String的静态方法valueOf
-
先把基本类型装箱成对象，然后调用对象的toString方法。
public class TestNumber { public static void main(String[] args) { int i = 5; //方法1 String str = String.valueOf(i); //方法2 Integer it = i; String str2 = it.toString(); } }
-
字符串转数字
调用Integer的静态方法parseInt
public class TestNumber { public static void main(String[] args) { String str = "999"; // 字符串转数字 int i= Integer.parseInt(str); System.out.println(i); } }9.6、数学方法
java.lang.Math提供了一些常用的数据运算方法，并且都是以静态方法的形式存在。
9.7、格式化输出
printf、format
9.8、字符
- 保存一个字符的时候用char
- char对应的封装类：Character
- Character的常见方法：isLetter、isDigit、isUpperCase等
9.9、字符串
- String是被final修饰的，所以是不能被继承的。
- immutable，不可改变的。一旦创建好这个字符串，里面的内容永远不能改变。String表现的就像是一个常量。
- length方法返回当前字符串的长度
- 比较字符串对象是否相同
- 比较字符串内容是否相同：equals、equalsIgnoreCase
- StringBuffer是可变长的字符串，常用api：append、delete、insert、reverse。
10、日期
10.1、Date
- Date类，是java.util.Date
- 时间原点：格林威治时间的1970年的0时0分0s
- 当前日期的毫秒数：System.currentTimeMillis
10.2、日期格式化
SimpleDateFormat，日期格式化类
-
日期转字符串，format
public class TestDate { public static void main(String[] args) { //y 代表年 //M 代表月 //d 代表日 //H 代表24进制的小时 //h 代表12进制的小时 //m 代表分钟 //s 代表秒 //S 代表毫秒 SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS" ); Date d= new Date(); String str = sdf.format(d); System.out.println("当前时间通过 yyyy-MM-dd HH:mm:ss SSS 格式化后的输出: "+str); SimpleDateFormat sdf1 =new SimpleDateFormat("yyyy-MM-dd" ); Date d1= new Date(); String str1 = sdf1.format(d1); System.out.println("当前时间通过 yyyy-MM-dd 格式化后的输出: "+str1); } }
-
字符串转日期，parse
public class TestDate { public static void main(String[] args) { SimpleDateFormat sdf =new SimpleDateFormat("yyyy/MM/dd HH:mm:ss" ); String str = "2016/1/5 12:12:12"; try { Date d = sdf.parse(str); System.out.printf("字符串 %s 通过格式 yyyy/MM/dd HH:mm:ss %n转换为日期对象: %s",str,d.toString()); } catch (ParseException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
10.3、Calendar
日历类
-
Calendar与Date进行转换
// 采用单例模式，获取日历对象 Calendar c = Calendar.getInstance(); // 通过日历对象，获取日期对象 Date d = c.getTime(); -
翻日历
public static void main(String[] args) { Calendar c = Calendar.getInstance(); Date now = c.getTime(); // 当前日期 System.out.println("当前日期：\t" + format(c.getTime())); // 下个月的今天 c.setTime(now); c.add(Calendar.MONTH, 1); System.out.println("下个月的今天:\t" +format(c.getTime())); // 去年的今天 c.setTime(now); c.add(Calendar.YEAR, -1); System.out.println("去年的今天:\t" +format(c.getTime())); // 上个月的第三天 c.setTime(now); c.add(Calendar.MONTH, -1); c.set(Calendar.DATE, 3); System.out.println("上个月的第三天:\t" +format(c.getTime())); }
参考资料：http://how2j.cn/stage/12.html