为了能够了解程序员大师们的解题思路,以便对症下药的解决问题,开始学习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,创建
ArrayList<Egg> myList = new ArrayList<Egg>();
//<>限制类型,也就是这个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<String> ln = new LinkedList<String>();
ln.add("a");
ln.addFirst("a0");//头添加
ln.addLast("b");//尾添加
String f = ln.getFirst();//取头数据
String l = ln.getLast();//取尾数据
- List接口允许重复,Set接口不可重复,HashSet查询快,TreeSet排序;
HashSet<String> hs = new HashSet<String>();
hs.add("a");
hs.add("b");
hs.add("a");
System.out.println(hs);//a,b
TreeSet<String> ts = new TreeSet<String>();
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...")
}
}