GPHPER的菜地


  • 首页

  • 标签

  • 分类

  • 归档

Java基础(九) -- 泛型

发表于 2022-05-28 | 分类于 Java

注意事项

  • 泛型中使用的类型只能是引用类型,不能是基础数据类型。例如 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

    阅读全文 »

Java基础(四)--object

发表于 2022-05-20 | 分类于 Java

equals 方法

  • ==

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

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

Java基础(五)--静态变量和方法

发表于 2022-05-20 | 分类于 Java

静态变量

  • 会被所有的实例化出来的对象共享该类的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;
}
}
阅读全文 »

Java基础(六) -- Final、抽象类、接口

发表于 2022-05-20 | 分类于 Java

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(){
    // 覆写不被允许
    }
    }
    阅读全文 »

Java基础(七) -- 内部类

发表于 2022-05-20 | 分类于 Java
  • 类的五个成员:属性、方法、构造器、代码块、内部类

局部内部类

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();
}
}
阅读全文 »

Java基础(七) -- 枚举和注解

发表于 2022-05-20 | 分类于 Java

枚举

  • 自定义枚举类
    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;
    }
    }
    阅读全文 »

Java基础(七) -- 异常处理

发表于 2022-05-20 | 分类于 Java

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 {

    }
    }
    阅读全文 »

Java基础(二)

发表于 2022-05-11 | 分类于 Java

1.数组

  • 静态初始化

    元素类型[] 变量名称 = {元素1,元素2,元素3}

  • 动态分配

    元素类型[] 变量名 = new 元素类型[数组长度]

  • 获取长度

    变量名.length

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

    阅读全文 »

Java基础(三)--类和对象

发表于 2022-05-11 | 分类于 Java

快速入门

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

}
阅读全文 »

Java基础(四)--面向对象

发表于 2022-05-11 | 分类于 Java

1.包

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

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

    阅读全文 »
<1234>

33 日志
6 分类
12 标签
© 2024 GPHPER
由 Hexo 强力驱动
|
主题 — NexT.Mist v5.1.4