一枚c/c++程序员java探索－对象（二）

发表于 | 分类于 | | 阅读次数
对象！！

我们接着上一章来说

Package 和 import 语句

  1. 为了便于管理软件系统中数目众多的类，解决类名冲突问题，利用package机制

  2. Package语句作为Java源文件的第一条语句，指该文件类所在的包（若没有该语句，则为无名包） 格式： package pkg1[.pkg2[.pkg3….]];

Java中，包相当于文件系统的目录管理，用‘ . ’来指明包（目录）的层次 例如 ：package com.example (则该文件中所有类位于 ./com/example)

类的继承和权限控制

  • Java中使用extends关键字实现类的继承机制

  • 通过继承，子类自动拥有了父类的所有成员（成员变量和方法）

  • Java只支持单继承，不用许多继承（一个子类只能有一个父类，一个父类可以派生多个子类）

  • Java权限修饰符 public protect private 置于类的成员定义前，用来限定其他对象对该类对象成员的访问权限

  • 对于class的权限修饰只可以用public 和 default

    Public可以在任意地方被访问

    Default类只可以被同一个包内部的类访问

方法重写

  • 在子类中可以根据需要对从父类中继承的方法进行重写

  • 重写方法必须和被重写方法具有相同方法名称，参数列表和返回类型

  • 重写方法不能使用比被重写方法更严格的访问权限

Super关键字

  • 用super引用父类成分

继承中的构造方法

  • 子类的构造过程中必须调用其父类的构造方法

  • 子类可以在自己构造方法中使用super调用父类的构造方法，而且必须写在子类构造方法的第一行（this是调用本类的另外的构造方法）

  • 如果子类的构造方法中没有显示地调用父类构造方法，则系统默认调用父类无参数的构造函数

  • 如果子类构造方法中既没有显示调用父类构造方法，而父类中又没有无参数的构造方法，则编译出错

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
59
60
61
62
63
64
65
66
    class SuperClass {
    private int nnt;    
    SuperClass() {
        System.out.println("SuperClass()");
    }
   
    SuperClass(int n) {
        System.out.println("SuperClass(" + n + ")");
        this.n = n;
    }
}
 
class SubClass extends SuperClass {
    private int n;
   
    SubClass(int n) {
                  //super();
        System.out.println("SubClass(" + n + ")");
        this.n = n;
    }
   
    SubClass() {
                  super(300);
        System.out.println("SubClass()");
    }
}
 
public class TestSuperSub {
    public static void main(String arg[]) {
        //SubClass sc1 = new SubClass();
        SubClass sc2 = new SubClass(400);
    }
}

Object类

  • Object类是所有Java类的根父类

  • 如果在类的声明中未使用extends关键字指明其父类，则默认父类为object类

Tostring方法

  1. object 类中定义有public string tostring（）方法，返回值是string类型

  2. 在进行string与其他数据类型的链接操作时（如：system.out.println(‘’info’’+person)）,将自动调用该对象类的string方法

  3. 可以根据需要在用户自定义类型中重写tostring（）方法

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 TestToString {
       public static void main(String[] args) {
              Dog d = new Dog();
              System.out.println("d:=" + d);
       }
}
 
class Dog {
       public String toString() {
              return "I'm a cool dog!";
       }
}

Equals方法

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
public class TestEqual {
       public static void main(String[] args) {
              Integer i1 = new Integer(1);
              Integer i2 = new Integer(1);
              System.out.println(i1 == i2);
              System.out.println(i1.equals(i2));
              Mao m1 = new Mao("A", "A");
              Mao m2 = new Mao("A", "A");
              System.out.println(m1 == m2);
              System.out.println(m1.equals(m2));
       }
}
 
class Mao {
       String name;
  String color;
  Mao(String n,String c){
    name = n; color = c;
  }
 
  public boolean equals(Object obj) {
         return true;
  }
}

对象转型

  1. 一个父类的引用类型变量可以指向子类对象

  2. 一个父类的引用不可以访问其子类对象新增的成员（属性和方法）

  3. 可以使用 引用 变量instanceof类名，来判断该引用型变量所指向的对象是否属于该类或该类的子类

  4. 子类的对象可以当作父类的对象来使用，称作向上转型，反之想向下转型

动态绑定/多态

指在执行期间（而非编译期）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
abstract class Animal {
  private String name;
  Animal(String name) {this.name = name;}
  /*
  public void enjoy(){
    System.out.println("叫声......");
  }
  */
  public abstract void enjoy();
}
 
abstract class Cat extends Animal {
  private String eyesColor;
  Cat(String n,String c) {super(n); eyesColor = c;}
  /*
  public void enjoy() {
    System.out.println("猫叫声......");
  }
  */
  //public abstract void enjoy();
}
 
class Dog extends Animal {
  private String furColor;
  Dog(String n,String c) {super(n); furColor = c;}
 
  public void enjoy() {
    System.out.println("狗叫声......");
  }
}
 
class Bird extends Animal {
       Bird() {
              super("bird");
       }
       public void enjoy() {
    System.out.println("鸟叫声......");
  }
}
 
class Lady {
    private String name;
    private Animal pet;
    Lady(String name,Animal pet) {
        this.name = name; this.pet = pet;
    }
    public void myPetEnjoy(){pet.enjoy();}
}
 
public class Test {
    public static void main(String args[]){
        Cat c = new Cat("catname","blue");
        Dog d = new Dog("dogname","black");
        Bird b = new Bird();
        //Lady l1 = new Lady("l1",c);
        Lady l2 = new Lady("l2",d);
        Lady l3 = new Lady("l3",b);
       //l1.myPetEnjoy();
        l2.myPetEnjoy();
        l3.myPetEnjoy();
    }
}

Final 关键字

  1. Final的变量的值不能够被改变

  2. Final的方法不能够被继承

  3. Final的类不能够被继承

接口（interface）

接口是抽象方法和常量值的定义的集合

本质上，接口是一种特殊的抽象类，这种抽象类中包含常量和方法的定义，而没有变量和方法的实现

特性

1.可以多重实现

2.接口中声明的属性默认为 public static final 的，也只能是他们

3.接口中只能定义抽象方法，而且是public的

4.接口可以继承其他的接口，并添加其他的属性和抽象方法

JasonThink wechat
欢迎您扫一扫上面的微信公众号，订阅我的博客！