JAVA基础
一、关键字列表
二、操作符
长路与&,短路与&&
带符号右移 >>
对于正数, 带符号右移 >> 会把所有的位右移,并在最前面补0
对于负数, 带符号右移 >> 会把所有的位右移,并在最前面补1
无符号右移>>>
如果是一个负数,那么对应的二进制的第一位是1
无符号右移>>>会把第一位的1也向右移动,导致移动后,第一位变成0
这样就会使得负数在无符号右移后,得到一个正数
简单的说:
带符号右移 >> 移动后正的还是正的,负的还是负的,符号不变
无符号右移>>>移动后,变正的了
三、控制流程
switch
可以使用byte,short,int,char,String,enum
注: 每个表达式结束,都应该有一个break;
注: String在Java1.7之前是不支持的, Java从1.7开始支持switch用String的,编译后是把String转化为hash值,其实还是整数
注: enum是枚举类型
标签
在外部循环的前一行,加上标签
在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; //如果是双数,结束外部循环 } } } }
四、数组
数组初始化
public class HelloWorld { public static void main(String[] args) { //写法一: 分配空间同时赋值 int[] a = new int[]{100,102,444,836,3236}; //写法二: 省略了new int[],效果一样 int[] b = {100,102,444,836,3236}; //写法三:同时分配空间,和指定内容 //在这个例子里,长度是3,内容是5个,产生矛盾了 //所以如果指定了数组的内容,就不能同时设置数组的长度 int[] c = new int[3]{100,102,444,836,3236}; } }
System.arraycopy复制数组
public class HelloWorld { public static void main(String[] args) { int a [] = new int[]{18,62,68,82,65,9}; int b[] = new int[3];//分配了长度是3的空间,但是没有赋值 //通过数组赋值把,a数组的前3位赋值到b数组 //方法一: for循环 for (int i = 0; i < b.length; i++) { b[i] = a[i]; } //方法二: System.arraycopy(src, srcPos, dest, destPos, length) //src: 源数组 //srcPos: 从源数组复制数据的启始位置 //dest: 目标数组 //destPos: 复制到目标数组的启始位置 //length: 复制的长度 System.arraycopy(a, 0, b, 0, 3); //把内容打印出来 for (int i = 0; i < b.length; i++) { System.out.print(b[i] + " "); } } }
Arrays方法
http://how2j.cn/k/array/array-arrays/516.html
import java.util.Arrays; public class HelloWorld { public static void main(String[] args) { int a[] = new int[] { 18, 62, 68, 82, 65, 9 }; // copyOfRange(int[] original, int from, int to) // 第一个参数表示源数组 // 第二个参数表示开始位置(取得到) // 第三个参数表示结束位置(取不到) int[] b = Arrays.copyOfRange(a, 0, 3); for (int i = 0; i < b.length; i++) { System.out.print(b[i] + " "); } } }
五、类和对象
可变参数
如果要攻击更多的英雄,就需要设计更多的方法,这样类会显得很累赘,像这样:
这时,可以采用可变数量的参数
只需要设计一个方法
public void attack(Hero...heros)
即可代表上述所有的方法了
在方法里,使用操作数组的方式处理参数heros即可
public class ADHero extends Hero { public void attack() { System.out.println(name + " 进行了一次攻击 ,但是不确定打中谁了"); } // 可变数量的参数 public void attack(Hero... heros) { for (int i = 0; i < heros.length; i++) { System.out.println(name + " 攻击了 " + heros[i].name); } } public static void main(String[] args) { ADHero bh = new ADHero(); bh.name = "赏金猎人"; Hero h1 = new Hero(); h1.name = "盖伦"; Hero h2 = new Hero(); h2.name = "提莫"; bh.attack(h1); bh.attack(h1, h2); } }
访问修饰符
继承概念模糊,不必深究。总之private子类不能直接访问
在我看来, 子类继承父类的一切东西. <Thinking in JAVA>中说到, 子类对象拥有父类对象的完整拷贝. 实例化一个类是从最顶级的超类开始实例化的, 是一层一层的包裹结构. private限制访问方式只能在类的内部, 这仅仅是一个访问控制, 实际上子类对象拥有父类对象的一切.
1. 属性通常使用private封装起来
2. 方法一般使用public用于被调用
3. 会被子类继承的方法,通常使用protected
4. package用的不多,一般新手会用package,因为还不知道有修饰符这个东西
再就是作用范围最小原则
简单说,能用private就用private,不行就放大一级,用package,再不行就用protected,最后用public。 这样就能把数据尽量的封装起来,没有必要露出来的,就不用露出来了
对象属性初始化
package charactor; public class Hero { public String name = "some hero"; //声明该属性的时候初始化 protected float hp; float maxHP; { maxHP = 200; //初始化块 } public Hero(){ hp = 100; //构造方法中初始化 } }
类属性初始化
package charactor; public class Hero { public String name; protected float hp; float maxHP; //物品栏的容量 public static int itemCapacity=8; //声明的时候 初始化 static{ itemCapacity = 6;//静态初始化块 初始化 } public Hero(){ } public static void main(String[] args) { System.out.println(Hero.itemCapacity); } }
饿汉式单例模式
GiantDragon 提供了一个public static的getInstance方法,外部调用者通过该方法获取12行定义的对象,而且每一次都是获取同一个对象。 从而达到单例的目的。
这种单例模式又叫做饿汉式单例模式,无论如何都会创建一个实例
package charactor; public class GiantDragon { //私有化构造方法使得该类无法在外部通过new 进行实例化 private GiantDragon(){ } //准备一个类属性,指向一个实例化对象。 因为是类属性,所以只有一个 private static GiantDragon instance = new GiantDragon(); //public static 方法,提供给调用者获取12行定义的对象 public static GiantDragon getInstance(){ return instance; } }
懒汉式单例模式
懒汉式单例模式与饿汉式单例模式不同,只有在调用getInstance的时候,才会创建实例
package charactor; public class GiantDragon { //私有化构造方法使得该类无法在外部通过new 进行实例化 private GiantDragon(){ } //准备一个类属性,用于指向一个实例化对象,但是暂时指向null private static GiantDragon instance; //public static 方法,返回实例对象 public static GiantDragon getInstance(){ //第一次访问的时候,发现instance没有指向任何对象,这时实例化一个对象 if(null==instance){ instance = new GiantDragon(); } //返回 instance指向的对象 return instance; } }
饿汉式是立即加载的方式,无论是否会用到这个对象,都会加载。
如果在构造方法里写了性能消耗较大,占时较久的代码,比如建立与数据库的连接,那么就会在启动的时候感觉稍微有些卡顿。
懒汉式,是延迟加载的方式,只有使用的时候才会加载。 并且有线程安全的考量(鉴于同学们学习的进度,暂时不对线程的章节做展开)。
使用懒汉式,在启动的时候,会感觉到比饿汉式略快,因为并没有做对象的实例化。 但是在第一次调用的时候,会进行实例化操作,感觉上就略慢。
看业务需求,如果业务上允许有比较充分的启动和初始化时间,就使用饿汉式,否则就使用懒汉式
三元素
1. 构造方法私有化
2. 静态属性指向实例
3. public static的 getInstance方法,返回第二步的静态属性
枚举enum
枚举enum是一种特殊的类(还是类),使用枚举可以很方便的定义常量
比如设计一个枚举类型 季节,里面有4种常量
一个常用的场合就是switch语句中,使用枚举来进行判断
注:因为是常量,所以一般都是全大写
public enum Season { SPRING,SUMMER,AUTUMN,WINTER }
public class HelloWorld { public static void main(String[] args) { Season season = Season.SPRING; switch (season) { case SPRING: System.out.println("春天"); break; case SUMMER: System.out.println("夏天"); break; case AUTUMN: System.out.println("秋天"); break; case WINTER: System.out.println("冬天"); break; } } }
六、接口与继承
对象转型
隐藏
子类覆盖父类的类方法
内部类
内部类分为四种:
非静态内部类
静态内部类
匿名类
本地类
默认方法
默认方法是JDK8新特性,指的是接口也可以提供具体方法了,而不像以前,只能提供抽象方法
七、数字与字符串
数学方法
格式化输出
换行
为了使得同一个java程序的换行符在所有的操作系统中都有一样的表现,使用%n,就可以做到平台无关的换行
Character字符方法
字符串
字符串方法
比较字符串