【Java】面向对象编程

目录

🥬包

💧导入包中的类

💧 静态导入

💧将类放到包中

💧包的访问控制权限

🥬继承

💧final关键字

💧super关键字

💧protected 关键字

🥬组合

🥬多态

💧向上转型

💧动态绑定

💧方法重写

💧理解多态

🥬抽象类

🥬接口

🥬小结

---

🥬包

什么是包？

包 (package) 是组织类的一种方式 。使用包的主要目的是保证类的唯一性。

其实就相当于我们C语言中的库函数，里面放了已经封装好的类，当我们需要用到里面的字段和方法时，就可以通过包来导入。

💧导入包中的类

Java 中已经提供了很多现成的类供我们使用：例如下面这个打印数组的函数

public class Test {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5};
        System.out.println(Arrays.toString(arr));
    }
}

 这个就是导入包中的类，我们在在写代码的时候，要用一些已经写好的函数，我们就需要导入它，就是导入包中的类。我们需要哪个方法或者字段就引用哪个方法或者字段。

我们可以通过下图方式看到until这个包中的Arrays这个类。

那么package和import有什么区别呢？

package：“包”，指类所在的包

import:“引入”，引入类中所需要的类

import只能导入一个具体的类，不能导入一个包。

对于上面那种导入包中的类，我们还可以用*代替这个包中所有的类，until中有很多类，Java处理的时候会拿到自己想要的，并不是所有类都拿出来。

import java.util.*;

public class Test {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6};
        System.out.println(Arrays.toString(arr));
    }
}

 但是这种方法也有不好的地方，例如：

import java.sql.*;
public class Test {
    public static void main(String[] args) {
        // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
        Date date = new Date();
        System.out.println(date.getTime());
   }
}
// 编译出错
Error:(5, 9) java: 对Date的引用不明确
  java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

所以写完整的类名比较好。

💧 静态导入

使用 import static 可以导入包中的静态的方法和字段

import static java.lang.System.*;
public class Test {
    public static void main(String[] args) {
        out.println("hello");
   }
}

 静态导入的好处：

import static java.lang.Math.*;
public class Test {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
        // 静态导入的方式写起来更方便一些. 
        // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
        double result = sqrt(pow(x, 2) + pow(y, 2));
        System.out.println(result);
   }
}

上面讲的都是从包中导入一个具体的类，那我们怎么自己创建一个包，把类放到包中呢？

💧将类放到包中

基本规则

1、在文件的最上方加上一个 package 语句指定该代码在哪个包中。

2、包名需要尽量指定成唯一的名字 , 通常会用公司的域名的颠倒形式 ( 例如 com.caicai.demo1 )。

3、包名要和代码路径相匹配 . 例如创建 com.bit.demo1 的包 , 那么会存在一个对应的路 com/caicai/demo1 来存储代码。

4、如果一个类没有 package 语句 , 则该类被放到一个默认包中。

接下来看个例子：

 接下来我们可以看我们的磁盘目录结构已经被IDEA自动创建出来了：

 

 同时我们也可以看到，在新创建的TestDemo.java文件的最上方出现了一个package语句。该package 语句指定该代码在哪个包中。

💧包的访问控制权限

我们已经了解了类中的 public 和 private，private 中的成员只能被类的内部使用。（如果对private不懂得可以去我这篇文章看看）

如果某个成员不包含 public 和 private 关键字 , 此时这个成员可以在包内部的其他类使用 , 但是不能在包外部的类使用 。

下面的代码给了一个示例 ， Demo1 和 Demo2 是同一个包中 , Test 是其他包中。

Demo1.java:

package com.caicai.demo1;
public class Demo1 {
    int value = 0; 
}

Demo2.java:

package com.caicai.demo1; 

public class Demo2 { 
 public static void main(String[] args) { 
 Demo1 demo = new Demo1(); 
 System.out.println(demo.value); 
 } 
} 
// 执行结果, 能够访问到 value 变量
10

Test.java:

import com.caicai.demo2; 
public class Test { 
 public static void main(String[] args) { 
 Demo1 demo = new Demo1(); 
 System.out.println(demo.value); 
 } 
} 
// 编译出错
Error:(6, 32) java: value在com.caicai.demo2中不是公共的; 无法从外部程序包中对其进行访问

总结：包的访问控制权限就是说如果某个成员不含关键字public或者private，则该成员只能在该包内的其他类中使用，不能在其他包中使用。

🥬继承

什么是继承：

代码中创建的类 , 主要是为了抽象现实中的一些事物 ( 包含属性和方法 )。

有的时候客观事物之间就存在一些关联 , 那么在表示类和对象的时候也会存在一定的关联 。

（简单来说就是几个类中有完全相同的成员或者方法，我们可以把这些相同成员或者方法放在一个类（假设放在A）中，其他类（B，C……）可以通过继承来使用。A就是父类，B,C……就是子类。

继承的意义是为了代码的复用。

此时我们举个例子来看：

// Animal.java 
public class Animal { 
 public String name; 
 public Animal(String name) { 
 this.name = name; 
 } 
 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 


// Cat.java 
class Cat { 
 public String name; 
 
 public Cat(String name) { 
 this.name = name; 
 } 
 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 


// Bird.java 
class Bird { 
 public String name; 
 
 public Bird(String name) { 
 this.name = name; 
 } 
 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
 
 public void fly() { 
 System.out.println(this.name + "正在飞 ︿(￣︶￣)︿"); 
 } 
}

所以我们可以知道：

这三个类都具备一个相同的 eat 方法 , 而且行为是完全一样的 。

这三个类都具备一个相同的 name 属性 , 而且意义是完全一样的 。

从逻辑上讲 , Cat 和 Bird 都是一种 Animal (is - a 语义 )。

此时我们就可以让 Cat 和 Bird 分别继承 Animal