Java学习笔记

一.输入

1.scanner类：

a.导入java.util.Scanner

b.创建Scanner对象

c.接收并保存用户输入的值:

读入字符串：next();

读入小数：nextDouble();

读入整数：nextInt();

eg.

Scanner input = new Scanner(System.in);
int a= input.nextInt();
System.out.println(a);

二.输出

1.System.out.println(count);

三.数组

1.转自慕课网：

四.变量：

1.成员变量有默认初始值。局部变量没有默认初始值。

五.初始化块：

        1.静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。

2.程序运行时静态初始化块最先被执行（由上至下），然后执行普通初始化块（由上至下），最后才执行构造方法。

参考：http://www.cnblogs.com/miniwiki/archive/2011/03/25/1995615.html

六.包：

定义包：packge + 包名（全小写）;//必须放在源文件第一行，包名间可以用“.”隔开。

七.内部类：

慕课网-Java第二季-2-7

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

方法内部类：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

八.访问权限：

参考：http://www.cnblogs.com/xwdreamer/archive/2012/04/06/2434483.html

九.final、super

1.final：

修饰类使该类不能被继承；

修饰变量使该变量变为常量，在定义时必须要赋值，但是在构造函数中可以被修改。

2.super

调用父类的成员或方法。

十.Object

1.toString：默认返回类的地址信息；重写后可以返回类信息。

2.equals：默认判断两个对象的地址是否相同；重写后可以判断其他信息是否相同。

eg: a.equals(b);

3.getClass:返回类的类型，即类的代码信息，包括类名、成员个数等。

十一.强制转换

1.强制将父类转换成子类时：使用instanceof 

eg： 父类 instanceof 子类 （父类能否转换成子类），若父类含有子类的元素则返回true（可以强制转换），否则返回false（不可以强制转换）。

十二.抽象类abstract

1.规则：

a.abstract定义抽象类。

b.abstract定义抽象方法，只有声明，不需要实现。

c.包含抽象方法的类是抽象类。

d.抽象类中可以包含普通方法，也可以没有抽象方法。

e.不能创建抽象类的对象，可以定义抽象类引用指向一个普通类。

十三.接口

1.定义：类是单继承的，接口可以多继承。黄色部分若是没写，编译器会自动添加。

[public] [abstract] interface 接口名 [extends 父接口1，父接口2...]{

//常量及抽象方法定义

public static final int a = 10;

public abstract void f();

}

2.使用：extends 关键字必须在  implements 关键字之前

[修饰符] class 类名 extends 父类 implements 接口1，接口2....{

//如果继承了抽象类，需要实现其中的抽象方法；

//还要实现接口中的抽象方法。

}

3.可以使用匿名内部类来实现接口

十四.异常

1.异常结构

try中写可能抛出异常的代码，catch中写 捕获到异常后的处理方法，finally中的内容，无论是否出现异常都会执行。try块后可以接多个catch块，catch应按照由小范围到大范围的顺序写

eg. Exception e;

e.rintStackTrace();//输出异常类型及位置

十五 字符串

1.相同的字符串常量只有一个对象

eg：

String s1 = "abc";

String s2 = "abc";

return s1 == s2;//返回值是true

2. 一旦一个字符串在内存中创建，则这个字符串将不可改变。当改变时，相当于创建了一个新的字符串，变量将引用新的字符串。如果需要一个可以改变的字符串，我们可以使用StringBuffer或者StringBuilder。StringBuilder 和StringBuffer ，它们基本相似，不同之处在于，StringBuffer 是线程安全的，而 StringBuilder 则没有实现线程安全功能，所以性能略高。因此一般情况下，如果需要创建一个内容可变的字符串对象，应优先考虑使用 StringBuilder 类。

3.比较字符串的内容，使用.equals()方法，该方法在String类中被默认重新过了

4.字符串常用方法

十六 包装类

1.包装类主要提供了两大类方法： 将本类型和其他基本类型进行转换的方法； 将字符串和本类型及包装类互相转换的方法。

2.Interger包装类

(1)构造方法：

(2)常用转换方法：

除使用intValue()外，也可以直接使用 int i = n；//n是Integer类对象，此处使用了自动拆箱方式，参考  http://www.imooc.com/code/2250

(3)转为字符串

基本类型转换为字符串有三种方法： 使用包装类的 toString() 方法； 使用String类的 valueOf() 方法； 用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串。

eg. int c = 10;

String s1 = Integer.toString(c);

String s2 =String.valueOf(c);

String s3 =c + "";

(4)字符串转基本类型

将字符串转换成基本类型有两种方法： 调用包装类的 parseXxx 静态方法； 调用包装类的 valueOf() 方法转换为基本类型的包装类，会自动拆箱。

eg. String str = "123";

int a = Integer.parseInt(str);

int b = Integer.valueOf(str);

十六 框架

1.List：元素有序且可重复。ArrayList 的底层由数组实现，向其中插入元素时，指定的位置需要小于等于当前容量，否则会报错。

contains()方法的原理：contains方法会调用list内每个元素的equals()方法与目标进行比较，如果有一个是true，则返回true，否则返回false。

2.可以使用泛型来规定集合中可以放入的对象类型。

eg. List<Integer> a = new List<Integer>(); //即使规定了泛型，也可以向容器中存入泛型的子类，且泛型不可以使用基本类型，但可以使用基本类型的包装类

3.Set：元素无序且不可重复。由于无序，因此与List不同，Set没有get方法。若多次添加同一对象，只会保留第一次添加的那个。Set中可以添加空对象null

4.HashMap：多个KEY可以对应同一个value。Map中使用Entry类型作为键值对

5.使用带有Hash的容器时，在重写equals方法时应该同时重写hashcode方法，可是有IDE默认生成的。

6.使用Collection.sort(arraylist)对arraylist进行排序。对字符串排序时的排列顺序为0-9A-Za-z，若两个字符串第一位相同则比较第二位。

若对自定义的类进行排序，需要让类继承comparable<T>接口并使用泛型，并实现compareTo()方法；或者让类继承comparator<T>接口并使用泛型，并实现compare()方法

comparable接口：定义默认比较规则，实现该接口的类需要实现compareTo(object o)方法，返回正数表示大，返回负数表示小，返回0表示相等。

comparator接口：定义临时比较规则，实现该接口的类需要实现compare(object a,object b)方法，返回正数表示a大于b，返回负数表示a小于b，返回0表示相等

public int compareTo(Poker tempPoker) {
    if (this.bigger(tempPoker)) {
        return -1;
    }
    return 1;
}

由于在使用Collections.sort(listName)方法时，始终按照从小到大的顺序排序，所以当返回值是-1时，会被排在前边，返回值是1时，会被排在后边，返回值是0时尚不清楚规则

eg.  假设A和B是Poker的两个对象，则A.compareTo(B)的值是-1时，代表调用Collections.sort()方法时，A要排在B前边。

此外在使用comparator来实现临时比较规则时，需要定义一个新类实现该接口，然后在排序时调用。

eg. 假设现在要对ArrayList<A> a 进行排序，需要先创建类B应用接口comparator并重写compare方法，然后使用Collections.sort(a,new B());来排序。

类B：

public class ComparatorTest implements Comparator<Factors> {
    @Override
    public int compare(Factors o1, Factors o2) {
        if (o1.getProduct() < o2.getProduct()){
            return -1;
        }else if (o1.getProduct() > o2.getProduct()){
            return 1;
        }
        return 0;
    }
}

测试：

ArrayList<A> a = new ArrayList<A>();
a.add(...);
...
...
Collections.sort(result,new ComparatorTest());