注意事项

• 泛型中使用的类型只能是引用类型，不能是基础数据类型。例如 int 等

  1	ArrayList<int> ints = new ArrayList<int>(); // 错误的

• 实例化时指定了具体的类型后，实际传入的类型可以是该类型和该类型的子类型

  1 2 3 4 5 6 7 8 9 10 11 12

  import java.util.ArrayList; public class Generic { public static void main(String[] args) { ArrayList<A> list = new ArrayList<A>(); list.add(new B()); System.out.println(list); } } class A{} class B extends A{}

• 泛型可以简写

  1	ArrayList<String> strings = new ArrayList<>();

• 不指定泛型的话默认为 Object

  阅读全文 »

equals 方法

• ==

  • 即可以比较基本类型，又可以比较引用类型
  • 如果判断基础类型时，判断是值是否相等
  • 如果判断的是引用类型时，判断的是地址是否相等，即判断是不是同一个对象

• equals

  • 只能比较引用类型
    阅读全文 »

静态变量

• 会被所有的实例化出来的对象共享该类的static变量
• 可以通过类名直接访问
• 静态变量 jdk8 以前是分配在静态域里面，之后是分配到堆里面
• static 变量实在类加载的时候生成的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public class ChildGame{

    public static void main(String[] args) {
        Child child1 = new Child("小孩1");
        child1.join();

        Child child2 = new Child("小孩2");
        child2.join();

        System.out.println("加入游玩的人数"+child1.getCount());
    }

}

class Child {
    private static int count;
    private String name;

    public Child(String name) {
        this.name = name;
    }

    public int join(){
        Child.count ++;
        return Child.count;
    }

    public int getCount(){
        return Child.count;
    }
}

Final

• 不希望别被其他类继承

  1 2 3

  final class A { }

• 不希望父类的某个方法被子类修改则使用final修饰

  1 2 3 4 5 6 7 8 9 10 11 12

  class A{ public final void h1(){ } } class B extends A{ @override public void h1(){ // 覆写不被允许 } }

  阅读全文 »

• 类的五个成员：属性、方法、构造器、代码块、内部类

局部内部类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class InnerClass {
    public static void main(String[] args) {
        OutClass outClass = new OutClass();
        outClass.m1();
    }
}

class OutClass{
    private int n1 = 10;
    private void m2(){
        System.out.println("outclass m2()");
    }
    public void m1(){
        // 1.局部内部类时定义在外部类的局部位置，通常在方法
        // 3.不能添加访问修饰符，但是可以使用final修饰
        // 4.作用域：仅仅在定义它的方法或代码块中
        class Inner02{
            private int n1 = 800;
            //2. 可以直接访问外部类的所有成员，包括私有的
            public void i1(){
                // 5. 局部内部类可以直接访问外部类的成员，比如下面 外部类的n1和m2()
                // 7. 当内部类和外部类成员重名时，遵循就近一致原则，调用外部成员时使用 `外部类名.this.属性`
                System.out.printf("outclass n1 = %d ，外部类属性 = %d\n",n1,OutClass.this.n1);
                m2();
            }
        }

        // 6.外部类可以在方法中创建内部类对象，并调用方法
        Inner02 inner02 = new Inner02();
        inner02.i1();
    }
}

枚举

• 自定义枚举类

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

  public class Season { private String name; private String desc; // 枚举对象/属性使用 final+static 共同修饰，实现底层优化 public static final Season SPTING = new Season("春天","温暖"); public static final Season SUMMMER = new Season("夏天","炎热"); public static final Season AUTUMN = new Season("秋天","凉爽"); public static final Season WINTER = new Season("冬天","寒冷"); // 1.私有化构造器防止外部可以直接实例化对象 private Season(String name, String desc) { this.name = name; this.desc = desc; } // 2. 只允许访问属性，不允许修改属性 public String getName() { return name; } public String getDesc() { return desc; } }

  阅读全文 »

try-catch-finally

• 快捷键：ctrl+alt+t 选6

throws 异常

• throws 抛出异常让调用该方法的用户去处理该异常
• throws 后面可以更多个异常，使用,连接

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

  import java.io.FileInputStream; import java.io.FileNotFoundException; public class Exception01 { public static void main(String[] args) { Demo d = new Demo(); try { // 抛出的编译异常必须处理 d.say(); } catch (Exception e) { throw new RuntimeException(e); } // 抛出的运行时异常不必显示处理，方法后面默认有一个throws d.talk(); } } class Demo { // 或者 throws Exception // 这是抛出的编译时异常 public void say() throws FileNotFoundException { FileInputStream file = new FileInputStream("D:\\test.txt"); } // 抛出的运行时异常 public void talk() throws ClassFormatError { } }

  阅读全文 »

1.数组

• 静态初始化
  
  元素类型[] 变量名称 = {元素1,元素2,元素3}

• 动态分配
  
  元素类型[] 变量名 = new 元素类型[数组长度]

• 获取长度
  
  变量名.length

• 数组属于引用类型，数组型数据时对象

  阅读全文 »

快速入门

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

import java.util.Scanner;

public class Cat {
    public static void main(String[] args) {
        CatItem[] cats = new CatItem[2];
        cats[0] = new CatItem("小黑",20);
        cats[1] = new CatItem("小白", 30);

        Scanner scanner = new Scanner(System.in);

        String find = scanner.next();
        scanner.close();

        for(int i = 0;i < cats.length;i++){
            if(find.equals(cats[i].GetName())){
                System.out.println(cats[i].GetAge());
            }
        }

    }
}

class CatItem {

    private String name;
    private int age;

    public CatItem(String name,int age){
        this.name =  name;
        this.age = age;
    }

    public void SetName(String name){
        this.name = name;
    }

    public void SetAge(int age){
        this.age = age;
    }

    public String GetName(){
        return this.name;
    }

    public int GetAge(){
        return this.age;
    }

}

1.包

其实包就是文件夹和golang中的包一样，就是php中的命名空间

• 命名 com.公司名.项目名.业务模块名

  阅读全文 »