Java_note_2

Java_note_2

Charles Lv7
  2022-12-29 11:58:41 2022-12-29 11:58:41 Created   2023-02-09 09:45:35 2023-02-09 09:45:35 Updated      2.7k Words  12 Mins  

Java_note Object

1.Abstract_Class

folding code

Animal_demo.java

1
2
3
4
5
6
7
8
9
10
11
package note_file.Class_Object.Abstract_Class;

public class Animal_demo {
  public static void main(String[] args) {
    Animal a = new Cat();
    // 抽象类创建的对象
    a.eat();
    a.sleep();
  }
}

Animal.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package note_file.Class_Object.Abstract_Class;

public abstract class Animal {// 抽象类
  public abstract void eat();
  // 抽象方法

  public void sleep() {
    System.out.println("睡觉");
  }
  /*
   * details：
   * 1.利用关键字abstract
   * 2.抽象类里面可以有具体方法，也可以只有具体方法
   * 3.抽象方法一定在抽象类中
   * 4.抽象类要利用多态来创建对象
   * 5.抽象类的子类要么也是抽象类，要么要重写所有的抽象方法
   */
}

Cat.java

1
2
3
4
5
6
7
8
9
package note_file.Class_Object.Abstract_Class;

public class Cat extends Animal {
  @Override
  public void eat() {
    System.out.println("猫吃鱼");
  }
}

2.Inherit

folding code

Demo.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package note_file.Class_Object.Inherit;

public class Demo {
  public static void main(String[] args) {
    Fu f = new Fu();
    f.show();
    Zi z1 = new Zi();
    // 复习：主要在new时就已经使用了无参构造方法的调用
    // Zi中无参构造方法被调用时会先调用Fu的无参构造方法
    z1.method();
    // 调用父辈继承
    z1.show();
    Zi z2 = new Zi(19);
    // Zi中带参构造方法被调用时会先调用Fu的无参构造方法
    z2.method();
  }
}

Fu.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package note_file.Class_Object.Inherit;

public class Fu {
  public int age = 40;

  public void show() {
    System.out.println("Fu_age:\t\t" + age);
  }

  public Fu() {
    System.out.println("Fu无参构造方法被调用");
  }

  public Fu(int age) {
    System.out.println("Fu带参构造方法被调用");
  }
  // 以上两个方法为方法重载
}

Zi.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
package note_file.Class_Object.Inherit;

public class Zi extends Fu {
  // 上面一行使用了继承,一个子类只能继承一个父类，但可以存在多层继承
  public int height = 175;
  public int age = 20;
  // 子类有相同变量时会覆盖父类的继承

  public void method() {
    int age = 30;
    System.out.println("Zi_temp_age:\t" + age);
    // age的访问顺序为方法->成员变量->父辈成员变量,若要越级访问成员变量需要使用this指针，若要越级访问父辈成员变量需要使用super指针
    System.out.println("Zi_age:\t\t" + this.age);
    System.out.println("Fu_age\t\t" + super.age);
    System.out.println("Zi_height:\t" + height);
  }
  // 子类有相同方法时会覆盖父类的继承
  // 子类不能重写父类的private方法

  public Zi() {
    System.out.println("Zi无参构造方法被调用");
  }

  public Zi(int age) {
    super(20);// 通过这种方法调用父辈的带参构造方法，一般不写默认存在一个super();
    System.out.println("Zi带参构造方法被调用");
  }
  // 类中已经写了带参的构造方法，系统将不再提供无参的构造方法
}

3.Inner_Class

folding code

Inner_third.java

1
2
3
4
5
6
package note_file.Class_Object.Inner_Class;

public interface Inner_third {
  void show();
}

Outer_demo.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
package note_file.Class_Object.Inner_Class;

public class Outer_demo {

  public static void main(String[] args) {
    /*
     * * Outer.Inner_first oi = new Outer().new Inner_first();
     * // 内部类的创建方式
     * oi.show();
     */
    // 以上这种方式不常用，因为以上方式只适用于内部类为public，而更多内部类为private
    Outer o = new Outer();
    o.Inner_first_demo();// 调用成员内部类
    // 以上未注释的代码更常用
    o.Inner_second_demo();// 调用局部内部类
    o.Inner_third_demo();// 调用匿名内部类
    /*
     * Summary:
     * 1.局部内部类是在方法中定义的类，所以外界无法直接使用，需要在方法内部创建对象并使用
     * 2.该类可以直接访问外部类的成员(num1)，也可以访问方法内的局部变量(num2)
     */
  }

}

Outer.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
50
51
52
53
54
55
56
57
58
package note_file.Class_Object.Inner_Class;

public class Outer {
  private int num1 = 10;

  private class Inner_first {
    // 在类里面定义类即为内部类
    public void show() {
      System.out.println(num1);
    }
  }// 成员内部类
   // 注：内部类的作用是防止外界访问，故多为private

  public void Inner_first_demo() {
    Inner_first i = new Inner_first();
    i.show();
  }

  public void Inner_second_demo() {
    int num2 = 20;
    class Inner_second {
      public void show() {
        System.out.println(num1);
        System.out.println(num2);
      }
    }// 局部内部类
     // [tips:注意定义类时Inner_second后没有括号(),否则会报错(因为这不是一个方法)]
    Inner_second i = new Inner_second();
    i.show();
  }

  public void Inner_third_demo() {
    new Inner_third() {
      // 这里的Inner_third是创建的一个接口
      @Override
      public void show() {
        System.out.println("匿名内部类");
      }
      // 创建匿名内部类
    }.show();// 匿名内部类的本质是一个继承该类或者实现该接口的子类匿名对象，故可以调用方法(show();)

    // 也可以调用如下方法实现匿名内部类
    // Inter i=new Inner_third() {
    // @Override
    // public void show() {
    // System.out.println("匿名内部类");
    // }
    // }
    // i.show();

  }
  /*
   * Summary:
   * 1.内部类可以直接访问外部类的成员，包括私有
   * 2.外部类要访问内部类的成员，必须创建对象
   */
}

4.Operator

Abstract

folding code

Cat_demo.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package note_file.Class_Object.Operator.Abstract;

public class Cat_demo {
  public static void main(String[] args) {
    Cat c = new Cat();
    Cat_operator co = new Cat_operator();
    co.useCat(c);
    co.getCat().eat();
  }
  // 以上几行为类调用形参的用法，类似C的结构体
  /*
   * Summary:
   * 1.方法的形参是类名，其实需要的是该类的对象
   * 2.方法的返回值是类名，其实返回的是该类的对象
   */
}

Cat_operator.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package note_file.Class_Object.Operator.Abstract;

public class Cat_operator {
  public void useCat(Cat c) {
    c.eat();
  }

  public Cat getCat() {
    Cat c = new Cat();
    return c;
  }
  // 对象作为返回值
}

Cat.java

1
2
3
4
5
6
7
8
package note_file.Class_Object.Operator.Abstract;

public class Cat {
  public void eat() {
    System.out.println("猫吃鱼");
  }
}

Interface_demo

folding code

Cat.java

1
2
3
4
5
6
7
8
9
package note_file.Class_Object.Operator.Interface_demo;

public class Cat implements Jumping {
  @Override
  public void jump() {
    System.out.println("猫跳起来了");
  }
}

Jumping_demo.java

1
2
3
4
5
6
7
8
9
10
11
package note_file.Class_Object.Operator.Interface_demo;

public class Jumping_demo {
  public static void main(String[] args) {
    Jumping j = new Cat();
    Jumping_operator jo = new Jumping_operator();
    jo.use_Jumping(j);
    jo.get_Jumping().jump();
  }
}

Jumping_operator.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package note_file.Class_Object.Operator.Interface_demo;

public class Jumping_operator {
  public void use_Jumping(Jumping j) {
    j.jump();
  }

  // 接口名作为形参
  public Jumping get_Jumping() {
    Jumping j = new Cat();
    return j;
  }
  // 接口名作为返回值
  /*
   * Summary:
   * 1.方法的形参是接口名，其实需要的是该接口的实现类对象
   * 2.方法的返回值是接口名，其实需要的是该接口的实现类对象
   */
}

Jumping.java

1
2
3
4
5
6
package note_file.Class_Object.Operator.Interface_demo;

public interface Jumping {
  void jump();
}

5.Phone_Class

folding code

New_Phone.java

1
2
3
4
5
6
7
8
9
10
11
package note_file.Class_Object.Phone_Class;

public class New_Phone extends Phone {
  @Override // 重写父类的声明，为防止因粗心导致父类和重写子类名字不同时使用的
  public void call(String name) {
    System.out.println("开启视频功能");
    super.call(name);
  }
  // 以上代码为方法重写
}

Phone_demo1.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package note_file.Class_Object.Phone_Class;

public class Phone_demo1 {
  public static void main(String[] args) {
    Phone p = new Phone();
    // 默认初始化为null和0
    p.brand = "小米";
    p.price = 2999;
    System.out.println(p.brand);
    System.out.println(p.price);
    p.call("charles");
    p.send_message();
    Phone q = p;
    // 把第一个对象的地址赋值给了第二个对象,所以会使p,q同时发生改变
    q.brand = "华为";
    q.price = 3999;
    System.out.println(q.brand);
    System.out.println(q.price);
    System.out.println(p.brand);
    System.out.println(p.price);
  }
}

Phone_demo2.java

1
2
3
4
5
6
7
8
9
10
11
package note_file.Class_Object.Phone_Class;

public class Phone_demo2 {
  public static void main(String[] args) {
    Phone p = new Phone();
    p.call("charles");
    New_Phone np = new New_Phone();
    np.call("charles");
  }
}

Phone.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package note_file.Class_Object.Phone_Class;

public class Phone {
  String brand;
  int price;

  public void call(String name) {
    System.out.println("给" + name + "打电话");
  }

  public void send_message() {
    System.out.println("发短信");
  }
}

6.Polymorphic

folding code

Animal_demo.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
package note_file.Class_Object.Polymorphic;

public class Animal_demo {
  public static void main(String[] args) {
    Animal a1 = new Cat();
    // 以上一行为多态构造,即有父类引用指向子类对象
    System.out.println(a1.age);
    // System.out.println(a.weight);[报错]

    a1.eat();
    // a.playGame();[报错]

    // Summary:
    // 成员变量:编译看左边[看Animal里有没有该变量],执行看左边[输出Animal里变量的值]
    // 成员方法:编译看左边[看Animal里有没有该方法],执行看右边[输出Cat里的成员方法](原因:方法重写)

    /*
     * 多态的特点:
     * 1.好处:提高程序的拓展性
     * 具体体现:定义方法时,使用父类型作为参数,将来在使用时,使用具体的子类型进行操作
     * 2.弊端:不能使用子类特有的功能
     */

    /*
     * 多态的转型:
     * 1.向上转型:从子到父,父类引用指向子类对象
     */
    Animal a2 = new Cat();
    a2.eat();
    /*
     * 2.向下转型:从父到子,父类引用转为子类对象(类似强制类型转化)
     */
    Cat c = (Cat) a2;
    c.eat();
    c.playGame();
  }
}

Animal.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
package note_file.Class_Object.Polymorphic;

public class Animal {
  public String name;
  public int age = 40;

  public Animal() {
  }

  // 好用快捷键:Alt+Shift+S,选择Constructor可以快速生成以下几行代码
  public Animal(String name, int age) {
    this.name = name;
    this.age = age;
  }

  // 同理:选择Getters and Setters可以快速生成set/get方法

  public String getName() {
    return name;
  }

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

  public int getAge() {
    return age;
  }

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

  public void eat() {
    System.out.println("动物吃东西");
  }
}

Cat.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package note_file.Class_Object.Polymorphic;

public class Cat extends Animal {
  public int age = 20;
  public int weight = 10;

  public Cat() {
  }

  public Cat(String name, int age) {
    super(name, age);
  }

  @Override
  public void eat() {
    System.out.println("猫吃鱼");
  }

  public void playGame() {
    System.out.println("猫捉迷藏");
  }
}

7.Student_Class

folding code

Student_demo1.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package note_file.Class_Object.Student_Class;

public class Student_demo1 {
  public static void main(String[] args) {
    Student s1 = new Student();
    // 该行调用了Student的构造方法,属于无参构造方法
    // 使用set方法给成员变量赋值
    s1.set_name("charles");
    s1.set_age(19);
    s1.show();
    // 使用get方法获得成员变量的值
    System.out.println(s1.get_name() + ": " + s1.get_age());

    Student s2 = new Student("charles", 19);
    // 该行调用了Student的构造方法,属于带参构造方法
    s2.show();
  }
}

Student_demo2.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
package note_file.Class_Object.Student_Class;

import java.util.ArrayList;
import java.util.Scanner;

public class Student_demo2 {
  public static void main(String[] args) {
    try (Scanner sc = new Scanner(System.in)) {
      ArrayList<Student> array = new ArrayList<>();
      Student s1 = new Student("charles", 19);
      Student s2 = new Student("Lily", 43);
      Student s3 = new Student();
      s3.set_name(sc.nextLine());
      s3.set_age(sc.nextInt());
      array.add(s1);
      array.add(s2);
      array.add(s3);
      for (int i = 0; i < array.size(); i++) {
        System.out.println(i + 1 + "_name : " + array.get(i).get_name() + " age: " + array.get(i).get_age());
      }
      for (Student i : array) {
        System.out.println(i.get_age());
      }
    }
  }
}

Student.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
50
51
52
package note_file.Class_Object.Student_Class;

public class Student {
  private String name;
  private int age;

  // 构造方法（当类中没有写构造方法时，系统会给出默认的无参构造方法）
  public Student() {
    // System.out.println("我是charles");
  }

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

  public Student(int age) {
    this.age = age;
  }

  public Student(String name, int age) {
    this.name = name;
    this.age = age;
  }
  // 上面四个构造方法类似方法重载

  // get/set方法
  public void set_name(String name) {
    this.name = name;
  }
  // 由于成员变量和局部变量名称相同，所以要使用this关键字,this修饰的为成员变量

  public String get_name() {
    return name;
  }

  public void set_age(int age) {
    if (age < 0 || age > 120) {
      System.out.println("你给的年龄有误");
    } else {
      this.age = age;
    }
  }

  public int get_age() {
    return age;
  }

  public void show() {
    System.out.println(name + "," + age);
  }
}

  • Title: Java_note_2
  • Author: Charles
  • Created at : 2022-12-29 11:58:41
  • Updated at : 2023-02-09 09:45:35
  • Link: https://charles2530.github.io/2022/12/29/java-note-2/
  • License: This work is licensed under CC BY-NC-SA 4.0.
recommend_articles
matlab-note-10 matlab-note-10 Swift-note-9 Swift-note-9 linux-note-efficient linux-note-efficient
recommend_articles
matlab-note-10 matlab-note-10 Swift-note-9 Swift-note-9
Comments
On this page
Java_note_2
  1. Java_note Object
    1. 1.Abstract_Class
      1. Animal.java
      2. Cat.java
  2. 2.Inherit
    1. Fu.java
    2. Zi.java
  • 3.Inner_Class
    1. Outer_demo.java
    2. Outer.java
  • 4.Operator
    1. Abstract
      1. Cat_operator.java
      2. Cat.java
    2. Interface_demo
      1. Jumping_demo.java
      2. Jumping_operator.java
      3. Jumping.java
  • 5.Phone_Class
    1. Phone_demo1.java
    2. Phone_demo2.java
    3. Phone.java
  • 6.Polymorphic
    1. Animal.java
    2. Cat.java
  • 7.Student_Class
    1. Student_demo2.java
    2. Student.java