数组：

创建数组

数组是一个固定长度的，包含了相同类型数据的 容器
声明数组：
int[] a;声明了一个数组变量。
[]表示该变量是一个数组
int 表示数组里的每一个元素都是一个整数
a 是变量名数组
里面都是整数。但是这一句声明，不会创建数组
创建数组：
创建数组时候，就需要指明数组长度。

new int[5]

引用概念：
如果变量代表一个数组，比如a,我们把a叫做引用
与基本类型不同int c = 5; 这叫给c赋值为5
声明一个引用 int[] a;

a = new int[5];

让a这个引用，指向数组
创建方法：

'先声明，再创建'
int[] a;//声明一个引用
a = new int[5];//创建一个长度是5的数组，并且使用引用a指向该数组
'声明的同时，指向一个数组'         
int[] b = new int[5]; //声明的同时，指向一个数组

访问数组：a[0]
.length属性用于访问一个数组的长度a.length
找最小值：

public class Shuzu {public static void main(String[] args) {int[] a=new int[5]; //创建长度为5的数组a[0]=(int)(Math.random()*100); //随机整数赋值a[1]=(int)(Math.random()*100);a[2]=(int)(Math.random()*100);a[3]=(int)(Math.random()*100);a[4]=(int)(Math.random()*100);int c=a[0];//用来比较int b = 0;//用来计System.out.println("数据中的各个随机数是:");for(int i=0;i<a.length;i++) {b=a[i];System.out.println(b); /*进度比较*/if(c>b) {c=b;}}System.out.println("本练习的目的是，找出最小的一个值:"+c);}
}

数组赋值

1 .单个赋值：

        int[] a = new int[5]; //分配了长度是5的数组，但是没有赋值，没有赋值，那么就会使用默认值//作为int类型的数组，默认值是0         //进行赋值a[0] = 100;a[1] = 101;

2.分配空间同时赋值：

//写法一：
int[] a = new int[]{100,200,300}
//写法二：
int[] b = {100,102,444,836,3236};
//写法三 同时分配空间，和指定内容//长度是3，内容是5个，产生矛盾了，所以如果指定了数组的内容，就不能同时设置数组的长度
int[] b = new int[3]{100,102,444,836,3236};

数组排序：

1 选择法（相当于依次向后寻找最小值)
选择法排序的思路：
把第一位和其他所有的进行比较，只要比第一位小的，就换到第一个位置来，依次类推
2 冒泡排序（两个两个比较）

增强型数组for(int each : 数组名){…}

package j2se;public class lian {public static void main(String[] args) {int values [] = new int[]{18,62,68,82,65,9};   	         //增强型for循环遍历for (int each : values) {System.out.println(each);}
//找出最大值int max=0;for(int each: values) {if(each>max) {max=each;}}System.out.println("\n此数组中最大值是：\n"+max);}}

复制数组

把一个数组的值，复制到另一个数组中：

System.arraycopy(src, srcPos, dest, destPos, length)

src: 源数组
srcPos: 从源数组复制数据的起始位置
dest: 目标数组
destPos: 复制到目标数组的起始位置
length: 复制的长度
合并数组：

package j2se;public class lian {public static void main(String[] args) {int values [] = new int[]{18,62,68,82,65,9};int[] a = new int[]{10,20,30,60};int[] c = new int[values.length + a.length];System.arraycopy(values, 0, c, 0, values.length);System.arraycopy(a, 0, c, values.length, a.length);for (int each: c){System.out.print(each +" ");}}}

二维数组

int b[][] = new int[][]{{1,2,3},{4,5,6},{7,8,9}
};

public class HelloWorld {public static void main(String[] args) {//初始化二维数组，int[][] a = new int[2][3]; //有两个一维数组，每个一维数组的长度是3a[1][2] = 5;  //可以直接访问一维数组，因为已经分配了空间//只分配了二维数组int[][] b = new int[2][]; //有两个一维数组，每个一维数组的长度暂未分配b[0]  =new int[3]; //必须事先分配长度，才可以访问b[0][2] = 5;//指定内容的同时，分配空间int[][] c = new int[][]{{1,2,4},{4,5},{6,7,8,9}};}
}

创建二维数组，并找最大值，然后返回坐标：

package j2se;public class lian {public static void main(String[] args) {int a[][]=new int[5][5];for(int i=0;i<5;i++) {for (int j = 0; j < 5; j++) {a[i][j]=(int)(Math.random()*100);  System.out.print(a[i][j]+"\t");}System.out.println();}int maxn=a[0][0];int x=0;int y=0;for(int i=0;i<5;i++) {for (int j = 0; j < 5; j++) {if(a[i][j]>maxn) {  maxn=a[i][j];x=i;y=j;}                      }}      System.out.println("找出来最大的是："+maxn);System.out.println("其坐标是："+"["+x+"]"+"["+y+"]");}}

Arrays 数组工具类

数组复制：
copyOfRange进行数组复制
与System.arraycopy的不同：
System.arraycopy需要事先准备好目标数组，并分配长度
copyOfRange:只需要源数组就就可以了，通过返回值，就能够得到目标数组了。
需要注意的是 copyOfRange 的第3个参数，表示源数组的结束位置，是取不到的。
// copyOfRange(int[] original, int from, int to)
// 第一个参数表示源数组
// 第二个参数表示开始位置(取得到)
// 第三个参数表示结束位置(取不到)

import java.util.Arrays;public class HelloWorld {public static void main(String[] args) {int a[] = new int[] { 18, 62, 68, 82, 65, 9 };int[] b = Arrays.copyOfRange(a, 0, 3){ for (int i = 0; i < b.length; i++) {System.out.print(b[i] + " ");}}
}

转换为字符串:
如果要打印一个数组的内容，就需要通过for循环来挨个遍历，逐一打印
但是Arrays提供了一个toString()方法，直接把一个数组，转换为字符串，这样方便观察数组的内容

package j2se;import java.util.Arrays;public class lian {public static void main(String[] args) {int values [] = new int[]{18,62,68,82,65,9};String c = Arrays.toString(values);System.out.println(c);}}

排序:
Arrays工具类提供了一个sort方法,对数组进行排序。

		Arrays.sort(values);System.out.println(Arrays.toString(values));

搜索：
需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序
如果数组中有多个相同的元素，查找结果是不确定的
判断是否相同：

        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };int b[] = new int[] { 18, 62, 68, 82, 65, 8 };System.out.println(Arrays.equals(a, b));

填充：

		int a[] = new int[10];Arrays.fill(a, 5);

类和对象

引用的概念

如果一个变量的类型是 类类型，而非基本类型，那么该变量又叫做引用。

new Hero();

是创建了一个Hero对象，但是无法访问它。
要访问这个对象，必须使用引用来代表这个对象

Hero h = new Hero();

h这个变量就是Hero类型的，又叫做引用。=的意思指的h这个引用指向右侧创建的对象
多个引用，一个对象

 //使用一个引用来指向这个对象Hero h1 = new Hero();Hero h2 = h1;  //h2指向h1所指向的对象Hero h3 = h2; //h1,h2,h3五个引用，都指向同一个对象

一个引用，多个对象
引用garen指向新创建的对象（对象1）
同一个引用garen指向新创建的对象（对象2）
这个时候，对象1，就没有任何引用指向了

Hero garen =  new Hero();//对象1
garen =  new Hero();//对象2

例子：其中h4,h3,h1都指向一个对象。h2单独指向一个对象

package charactor;public class Hero {public String name;protected float hp;public static void main(String[] args) {Hero h1 =  new Hero();Hero h2 =  new Hero();Hero h3;Hero h4;h3 = h1;h4 = h3;}
}

继承

在LOL中，武器是物品的一种，也是有名称和价格的
所以在设计类的时候，可以让武器继承物品，从而继承名称和价格属性
继承格式：

public class Weapon extends Item{int damage; //攻击力public static void main(String[] args) {Weapon infinityEdge = new Weapon();infinityEdge.damage = 65; //damage属性在类Weapon中新设计的infinityEdge.name = "无尽之刃";//name属性，是从Item中继承来的，就不需要重复设计了infinityEdge.price = 3600;}}

方法重载

方法的重载指的是方法名一样，但是参数类型不一样
有一种英雄，叫做物理攻击英雄 ADHero
为ADHero 提供三种方法

public void attack()
public void attack(Hero h1)
public void attack(Hero h1, Hero h2)

方法名是一样的，但是参数类型不一样
在调用方法attack的时候，会根据传递的参数类型以及数量，自动调用对应的方法

package j2se;public class ADHero extends Hero{public void attack(){System.out.println(name+"进行了一次攻击 ，但是不确定打中谁了");}public void attack(Hero h1){System.out.println(name+"对"+h1.name+"进行了一次攻击");}public void attack(Hero h1,Hero h2){System.out.println(name + "同时对" + h1.name + "和" + h2.name + "进行了攻击 ");}public static void main(String[] args){ADHero bh = new ADHero();bh.name="寒冰";bh.hp = 1500;Hero h1 = new Hero();h1.name = "盖伦";Hero h2 = new Hero();h2.name = "提莫";bh.attack();bh.attack(h1);bh.attack(h1,h2);		}
}
'结果:'
寒冰进行了一次攻击 ，但是不确定打中谁了
寒冰对盖伦进行了一次攻击
寒冰同时对盖伦和提莫进行了攻击 

可变数量的参数
如果要攻击更多的英雄，就需要设计更多的方法，这样类会显得很累赘，参数过多。
这时，可以采用可变数量的参数
只需要设计一个方法

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);}}

构造方法

通过一个类创建一个对象，这个过程叫做实例化
实例化是通过调用构造方法(又叫做构造器)实现的。
相当于在实例化的时候赋值。相当于python中s = Std("Fan",26).

定义：
方法名和类名一样（包括大小写）
没有返回类型
实例化一个对象的时候，必然调用构造方法

public class Hero { String name;// 方法名和类名一样（包括大小写）// 没有返回类型public Hero() {System.out.println("实例化一个对象的时候，必然调用构造方法");} public static void main(String[] args) {//实例化一个对象的时候，必然调用构造方法Hero h = new Hero();} 
}
'实例化时就会输出：'
实例化一个对象的时候，必然调用构造方法

隐式的构造方法

public Hero(){  
}

无参的构造方法，如果不写，就会默认提供一个

提供了一个有参的构造方法

一旦提供了一个有参的构造方法
同时又没有显式的提供一个无参的构造方法
那么默认的无参的构造方法，就没有了

public class Hero {String name; //姓名float hp; //血量float armor; //护甲int moveSpeed; //移动速度//有参的构造方法//默认的无参的构造方法就失效了public Hero(String heroname){ name = heroname;}public static void main(String[] args) {Hero garen =  new Hero("盖伦"); Hero teemo =  new Hero(); //无参的构造方法“木有了”}  }

构造方法的重载

和普通方法一样，构造方法也可以重载

public class Hero {String name; //姓名float hp; //血量float armor; //护甲int moveSpeed; //移动速度//带一个参数的构造方法public Hero(String heroname){ name = heroname;}//带两个参数的构造方法public Hero(String heroname,float herohp){ name = heroname;hp = herohp;}public static void main(String[] args) {Hero garen =  new Hero("盖伦"); Hero teemo =  new Hero("提莫",383);}}

含多个参数

package test;public class Hero {String name;float hp;float armor;int moveSpeed;public Hero(String heroname,float heroHP,float heroArmor,int heroMoveSpeed) {name=heroname;hp=heroHP;armor=heroArmor;moveSpeed=heroMoveSpeed;       }public static void main(String[] args) {// TODO 自动生成的方法存根Hero h = new Hero("盖伦",616.28f,27.536f,350);System.out.println("name:"+h.name);System.out.println("hp:"+h.hp);System.out.println("armor:"+h.armor);System.out.println("moveSpeed:"+h.moveSpeed);}}

this

this这个关键字，相当于普通话里的“我”
小明说 “我吃了” 这个时候，“我” 代表小明,"我"代表当前人物
this即代表当前对象

通过this关键字访问对象的属性

和构造方法不同，构造方法实在实例化工程中实现的，即可以当作设置属性。而下面–

    public void setName1(String name){name = name;}

–上面，方法体中，就能访问到参数name，耳不能赋予属性name

package j2se;public class Hero {String name; //姓名float hp; //血量float armor; //护甲int moveSpeed; //移动速度//参数名和属性名一样//在方法体中，只能访问到参数namepublic void setName1(String name){name = name;}//为了避免setName1中的问题，参数名不得不使用其他变量名public void setName2(String heroName){name = heroName;}//通过this访问属性public void setName3(String name){//name代表的是参数name//this.name代表的是属性namethis.name = name;}public static void main(String[] args) {Hero  h =new Hero();h.setName1("teemo");System.out.println(h.name);h.setName2("garen");System.out.println(h.name);    h.setName3("死歌");System.out.println(h.name);    }}
'输出：'
null//不能访问到对象的属性
garen//设置不同的变量名
死歌//this.name直接给本对象的属性赋值

通过this调用其他的构造方法
如果要在一个构造方法中，调用另一个构造方法，可以使用this()

package j2se;public class Hero {String name; //姓名float hp; //血量float armor; //护甲int moveSpeed; //移动速度//带一个参数的构造方法public Hero(String name){System.out.println("一个参数的构造方法");this.name = name;}//带两个参数的构造方法public Hero(String name,float hp){this(name);System.out.println("两个参数的构造方法");this.hp = hp;}public static void main(String[] args) {Hero teemo =  new Hero("提莫",383);System.out.println(teemo.name);}}
输出结果:
一个参数的构造方法
两个参数的构造方法
提莫

传参

参数也是变量，所以传参分为
基本类型传参
类类型传参

基本类型传参
在方法内，无法修改方法外的基本类型参数

int hp = 50; //=就是给hp变量赋值
Hero h = new Hero();//=就是把h引用指向Hero

类类型传参
类类型又叫引用
第24行的引用 teemo与 第17行的引用hero，是不同的引用
第17行相当于新建了一个Hero
通过调用garen.attack(teemo, 100); 使得这两个引用都指向了同一个对象
所以在第18行hero.hp = hero.hp - damage; 就使得该对象的hp值，发生了变化

package(包)

把比较接近的类，规划在同一个包下

Hero,ADHero 规划在一个包，叫做charactor（角色）
Item,Weapon规划在另一个包下，叫做 property(道具)

在最开始的地方声明该类所处于的包名。

使用其他包下的类，必须import
使用同一个包下的其他类，直接使用即可(比如，可以直接继承)
但是要使用其他包下的类，必须import

import property.Weapon;

访问修饰符

成员变量有四种修饰符
private 私有的
package/friendly/default 不写
protected 受保护的
public 公共的
public 表示公共的：

public String name;

而maxHP 没有修饰符即代表package/friendly/default

float maxHP

以Hero为例
自身：指的是Hero自己
同包子类：ADHero这个类是Hero的子类，并且和Hero处于同一个包下
不同包子类：Support这个类是Hero的子类，但是在另一个包下
同包类： GiantDragon 这个类和Hero是同一个包，但是彼此没有继承关系
其他类：Item这个类，在不同包，也没有继承关系的类

红色代表不能：

那么什么情况该用什么修饰符呢？ 从作用域来看，public能够使用所有的情况。
但是大家在工作的时候，又不会真正全部都使用public,那么到底什么情况该用什么修饰符呢？

1. 属性通常使用private封装起来
2. 方法一般使用public用于被调用
3. 会被子类继承的方法，通常使用protected
4. package用的不多，一般新手会用package,因为还不知道有修饰符这个东西

再就是作用范围最小原则
简单说，能用private就用private，不行就放大一级，用package,再不行就用protected，最后用public。
这样就能把数据尽量的封装起来，没有必要露出来的，就不用露出来了

类属性、

当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性
当一个属性被声明成类属性，那么所有的对象，都共享一个值
与对象属性对比：
不同对象的 对象属性 的值都可能不一样。比如盖伦的hp 和 提莫的hp 是不一样的。
但是所有对象的类属性的值，都是一样的
类属性： 又叫做静态属性；对象属性： 又叫实例属性，非静态属性
给英雄设置一个类属性叫做“版权" (copyright), 无论有多少个具体的英雄，所有的英雄的版权都属于 Riot Games公司。

package charactor;public class Hero {public String name; //实例属性，对象属性，非静态属性protected float hp;static String copyright;//类属性,静态属性public static void main(String[] args) {Hero garen =  new Hero();garen.name = "盖伦";Hero.copyright = "版权由Riot Games公司所有";System.out.println(garen.name);System.out.println(garen.copyright);Hero teemo =  new Hero();teemo.name = "提莫";System.out.println(teemo.name);    System.out.println(teemo.copyright);}}

访问类属性

一、对象.类属性teemo.copyright
二、类.类属性
Hero.copyright

这两种方式都可以访问类属性，访问即修改和获取，但是建议使用第二种 类.类属性 的方式进行，这样更符合语义上的理解
如果teemo.copyright = “Fan”,那么所有对象的copyright属性都会被改变

类方法

类方法： 又叫做静态方法
对象方法： 又叫实例方法，非静态方法
区别：
访问一个对象方法，必须建立在有一个对象的前提的基础上
访问类方法，不需要对象的存在，直接就访问
声明类方法：

    public static void battleWin(){System.out.println("battle win");}

声明实例方法：

    public void die(){hp = 0;}

'访问类方法可以没有对象'
Hero garen =  new Hero();
Hero.battleWin();
"访问实例方法必须要有对象"
garen.name = "盖伦";
//必须有一个对象才能调用
garen.die();

访问类方法：

1. 对象.类方法
garen.battleWin();
2. 类.类方法 
Hero.battleWin();

什么时候设计对象方法，什么时候设计类方法
如果访问了对象属性，那么这个方法，就必须设计为对象方法；如果一个方法，没有调用任何对象属性，那么就可以考虑设计为类方法

属性初始化

对象属性初始化：
对象属性初始化有3种

1. 声明该属性的时候初始化
2. 构造方法中初始化
3. 初始化块

public String name = "some hero"; //声明该属性的时候初始化protected float hp;float maxHP;{     maxHP = 200; //初始化块       }  public Hero(){hp = 100; //构造方法中初始化     }  

类属性初始化

1. 声明该属性的时候初始化
2. 静态初始化块

public static int itemCapacity=8; //声明的时候 初始化static{ itemCapacity = 6;//静态初始化块 初始化 }   

单例模式

LOL里有一个怪叫大龙GiantDragon，只有一只，所以该类，只能被实例化一次
单例模式又叫做 Singleton模式，指的是一个类，在一个JVM里，只有一个实例存在。
饿汉式单例模式：
GiantDragon，通过私有化其构造方法，使得外部无法通过new 得到新的实例。然后GiantDragon提供public static的getInstance方法

package charactor;public class GiantDragon {//私有化构造方法使得该类无法在外部通过new 进行实例化private GiantDragon(){}//准备一个类属性，指向一个实例化对象。 因为是类属性，所以只有一个private static GiantDragon instance = new GiantDragon();//public static 方法，提供给调用者获取12行定义的对象public static GiantDragon getInstance(){return instance;}}

package charactor;public class TestGiantDragon {public static void main(String[] args) {//通过new实例化会报错
//      GiantDragon g = new GiantDragon();//只能通过getInstance得到对象GiantDragon g1 = GiantDragon.getInstance();GiantDragon g2 = GiantDragon.getInstance();GiantDragon g3 = GiantDragon.getInstance();//都是同一个对象System.out.println(g1==g2);System.out.println(g1==g3);}
}

懒汉式单例模式
懒汉式单例模式与饿汉式单例模式不同，只有在调用getInstance的时候，才会创建实例

package charactor;public class GiantDragon {//私有化构造方法使得该类无法在外部通过new 进行实例化private GiantDragon(){       }//准备一个类属性，用于指向一个实例化对象，但是暂时指向nullprivate static GiantDragon instance;//public static 方法，返回实例对象public static GiantDragon getInstance(){//第一次访问的时候，发现instance没有指向任何对象，这时实例化一个对象if(null==instance){instance = new GiantDragon();}//返回 instance指向的对象return instance;}}

package charactor;public class TestGiantDragon {public static void main(String[] args) {//通过new实例化会报错
//      GiantDragon g = new GiantDragon();//只能通过getInstance得到对象GiantDragon g1 = GiantDragon.getInstance();GiantDragon g2 = GiantDragon.getInstance();GiantDragon g3 = GiantDragon.getInstance();//都是同一个对象System.out.println(g1==g2);System.out.println(g1==g3);}
}

饿汉式是立即加载的方式，无论是否会用到这个对象，都会加载。
如果在构造方法里写了性能消耗较大，占时较久的代码，比如建立与数据库的连接，那么就会在启动的时候感觉稍微有些卡顿。
懒汉式，是延迟加载的方式，只有使用的时候才会加载。 并且有线程安全的考量(鉴于同学们学习的进度，暂时不对线程的章节做展开)。
使用懒汉式，在启动的时候，会感觉到比饿汉式略快，因为并没有做对象的实例化。 但是在第一次调用的时候，会进行实例化操作，感觉上就略慢。
看业务需求，如果业务上允许有比较充分的启动和初始化时间，就使用饿汉式，否则就使用懒汉式

面试的时候经常会考的点，面试题通常的问法是:
什么是单例模式？
回答的时候，要答到三元素

1. 构造方法私有化
2. 静态属性指向实例
3. public static的 getInstance方法，返回第二步的静态属性

枚举类型

预先定义的常量：
枚举enum是一种特殊的类(还是类)，使用枚举可以很方便的定义常量
比如设计一个枚举类型 季节，里面有4种常量

public enum Season {SPRING,SUMMER,AUTUMN,WINTER
}

一个常用的场合就是switch语句中，使用枚举来进行判断
注：因为是常量，所以一般都是全大写

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;}}
}

枚举好处
假设在使用switch的时候，不是使用枚举，而是使用int，而int的取值范围就不只是1-4，有可能取一个超出1-4之间的值，这样判断结果就似是而非了。（因为只有4个季节）
但是使用枚举，就能把范围死死的限定在这四个当中
遍历枚举：

public class HelloWorld {public static void main(String[] args) {for (Season s : Season.values()) {System.out.println(s);}}
}

练习：

package charactor;public enum HeroType {TANK,WIZARD,ASSASSIN,ASSIST,WARRIOR,RANGED,PUSH,FARMING
}
public class HelloWorld {public static void main(String []args){for(HeroType HT:HeroType.values()){switch(HT){case TANK :System.out.println("坦克");break;case WIZARD :System.out.println("法师");break;case ASSASSIN :System.out.println("刺客");break;case ASSIST :System.out.println("辅助");break;case WARRIOR :System.out.println("近战");break;case RANGED :System.out.println("远程");break;case PUSH :System.out.println("推进");break;case FARMING :System.out.println("打野");break;}}}
}