为了能够了解程序员大师们的解题思路，以便对症下药的解决问题，开始学习java知识，目标是能读懂代码逻辑。这里记录下近期的学习知识。
- 源文件（比如party.java）经过编译（自动）后生成.class文件（paryt.class），java虚拟机运行.class文件输出结果
- 声明和赋值
int x = 3; //将数字3赋值给x，x被声明为int类型，注意以英文分号结束语句。
- 注释，不被代码执行的部分。
//双斜杠是注释
/*
这也是注释
*/
- 类-方法；方法是能够独立实现功能的程序片段；方法有静态方法（有关键字static，可以直接调用）和实例方法（没有关键字static，必须先实例化（new）才能调用）
public class Dog{//public：公开给其他类，class类声明，Dog是类名称（自取），必须有花括号。
int size;
String bread;
String name;
void bark(){//bark()是方法，必须有小括号，方法必须在类里面。
//在方法的花括号中编写方法应该执行的指令
if (size>60){//if判断，当小括号内为true时执行大括号内语句
System.out.println("woof!woof!")
} else if (size >14){//注意判断条件，逐级降低
System.out.println("Ruff!Ruff!")
} else {//上面条件都不满足时，执行本代码块内语句
System.out.println("Yip!Yip!")
}//结束if判断
}//方法结束
}//类结束
编写测试用的类
class DogTestDrive{
public static void main (String[] args){
Dog d = new Dog(); //Dog d 声明一个引用变量，new Dog() 创建一个对象，= 将新的Dog()对象赋值给d这个引用变量。
d.size = 40; //赋值（圆点运算符）
d.bark(); //调用方法
}
}
- System.out.print，当前行输出；System.out.println，新起一行输出
- 数组的声明、创建、调用和元素统计
String [] pets = {"dog","cat","rabbit"} //每个元素都要被引号包裹，元素间用逗号分隔
//java数组坐标是从0开始的，比如我要取第一个元素
String s = pet[0] // "dog"
//统计数组内元素个数
int x = pet.length // 3
- 变量的声明必须有类型和名称
- 方法可以有多个参数，在声明的时候用逗号分开，传入时也逗号分开
void go(){
TestStuff t = new TestStuff();
t.takeTwo(12,34);
}
void takeTwo(int x, int y){//声明一个拥有两个int参数的方法，方法名分别是x，y。12传给了x，34传给了y，12/34是实参，x/y是形参，按顺序赋值。注意，类型相同！
int z = x+y;
System.out.println(z);
}
- 实例变量声明在类内，有默认值，可不用初始化
- 局部变量声明在方法中，没有默认值，在使用前必须初始化
- 使用==比较两个primitive主数据类型，或者判断两个引用是否引用同一个对象
- 使用equals() 来判断两个对象是否在意义上相等
- 实力变量要标记为private，并通过getter与setter来存取，以确保实例变量值在合法范围内。
- for循环（加强版）
String [] s = {"a","b","c"}
for(String i:s){//注意变量类型一致String，i迭代寻找s里的每一个值，':'相当于in
System.out.println(i)
}
- for循环（基础版）
for(int i=0;i<100;i++){//int i=0:初始化；i<100:判断条件；i++：后递增运算符
System.out.println(i)
}
- 产生随机数
//randomNum:声明的一个保存随机数的变量
//(int):类型转换，把Math.random()*5的结果（double类型）转换成int类型
//Math:Java内建类，random()是其中一个方法，会产生一个介于0-1的小数
int randomNum = (int)(Math.random()*5)
- ArrayList类，读取快，是个对象，要用.运算符调用他的方法
1，创建
ArrayListmyList = new ArrayList ();
//<>限制类型，也就是这个ArrayList只接受Egg的对象
2，加入元素
Egg s= new Egg();
myList.add(s);
3，查询大小
int theSize = myList.size();
4，查询特定元素
boolean isIn = myList.contains(s);
5，判断集合是否为空
boolean empty = myList.isEmpty()；
6，删除元素
myList.remove(s)； - LinkedList 插入删除快，可以头尾添加
LinkedList ln = new LinkedList();
ln.add("a");
ln.addFirst("a0");//头添加
ln.addLast("b");//尾添加
String f = ln.getFirst();//取头数据
String l = ln.getLast();//取尾数据
- List接口允许重复，Set接口不可重复，HashSet查询快，TreeSet排序；
HashSet hs = new HashSet();
hs.add("a");
hs.add("b");
hs.add("a");
System.out.println(hs);//a,b
TreeSet ts = new TreeSet();
ts.add("c");
ts.add("a");
ts.add("b");
System.out.println(ts);//a,b,c
Map接口是一组成对的对象key-value，key不可重复。HashMap是无序的，TreeMap能够根据key自动排序。
“与”和“或”运算符（&&，||），不等于！=
引入，使用import，比如引入ArrayList： import java.util.ArrayList; 放在代码最顶部
继承：extend，减少子类中代码重复，子类可以直接使用父类中的实力变量和方法。构造方法（方法名与类名相同，没有返回值）不能被继承
//语法
class 子类名 extends 父类名 {}
- 覆盖：由子类重新定义继承下来的方法，以改变或者延伸方法
- 多态下，引用和对象可以是不同的类型，比如Animal myDog = new Dog();引用类型可以是实际对象类型的父类。
- 参数和返回类型也可以多态（注意PetOwner里调用giveShot方法传参d，h都是Animal a的子类）
class Vet{
public void giveShot(Animal a){
//a参数可以用任何Animal的类型对象来当传入
//当执行到makeNoise()的时候，不管它引用的对象是什么，该对象都会执行makeNoise()
a.makeNoise();
}
}
class PetOwner{
public void start(){
Vet v = new Vet();
Dog d = new Dog();
Hippo h = new Hippo();//Animal的子类即可
v.giveShot(d);//会执行Dog的makeNoise();
v.giveShot(h);//会执行Hippo的makeNoise();
}
- 方法的重载（overload），两个方法的名称相同，但是参数类型、个数不同。
public class Overloads{
String uniqueID;
public int addNums(int a ,int b){
return a+b;
}
public double addNums(double a ,double b){
//这里的方法名称相同，但是方法的返回值类型，参数类型不同
return a+b;
}
}
- 抽象类（不能被实例化（new）的类）关键词“abstract”，抽象类的目的就是被继承，除此之外没别的意义，比如Animal
- 不是抽象的类就是具体类，比如Dog，Cat
- 抽象的方法，没有实体。如果声明出一个抽象方法，那么就一定要放在抽象类里面，不能非抽象类内声明抽象方法。好处就是--多态，所有子类都能用到这些抽象方法
public abstract void eat();//分号结尾没有方法体{}
- this关键字，表示对当前对象的调用
- final关键字，在类前面：阻止继承；在方法前面：阻止方法覆盖；在属性前面：常量
- 接口
//语法
[public][abstract] interface interfaceName{}
- 实现接口，使用关键字implement，一个类必须实现接口中的所有方法，一个类可以实现多个接口，用逗号隔开。
- 内部类的引用类型转换：向上转换Dog——>Animal；向下转换Animal——>Dog
- 里氏代换原则：父类出现的地方，子类一定可以出现
public class Test{
public static void main(String [] args){
Pet cat = new Cat();//向上转换
Pet dog = new Dog();
Person per = new Person();//new一个对象
per.care(cat);//调用care方法
per.care(dog);//里氏代换，带还了父类里的Pet
}
}
interface Pet{//定义接口
public void run();
}
class Person{
public void care(Pet p){
p.run();
}
}
class Cat implements Pet{//实现接口
public void run(){
System.out.println("cat run...")
}
}
class Dog implements Pet{
public void run(){
System.out.println("dog run...")
}
}