java面向对象——包+继承+多态（一）
文章目录
- 包（package）
-
- 概念：
- 创建包
- 注意事项：
- 导入包中的类：
-
- 直接导入
- import语句导入
- 注意事项：
- 静态导入（了解即可）
- 包的访问权限
- 常见的系统包
- 继承
-
- 继承的语法规则
- 注意要点：
- super关键字（重点）
-
- 1 super（）帮助父类进行构造
-
- 注意事项：
- 2 super.func()调用父类的普通方法
- 3 super.data引用父类实例
- super关键字与this关键字的区别：
- protected关键字（重点）
-
- 1 在同一个类中
- 2 在同一个包中在不同的类
- 3 不同包底下的子类
- 4 不同包底下的非子类
- 访问权限的总结
- 更复杂的继承关系：（了解）
- 多态：
-
- 向上转型（重点)
- 向上转型发生的时机：
- 动态绑定（重点）
-
- 发生的条件：
- 静态绑定：
- 重写的注意事项
- 重写与重载的区别
- 结语：
包（package）
概念：
是组织类的一种方式，能够保证类的唯一性
创建包
在src包下点击new 然后package创建包，就能够创建出一个包，在创建的包下新建java class就会创建一个类。
注意事项：
1 在文件的最上方加上一个 package 语句指定该代码在哪个包中，比如创建一个class的包,在这个包下新建的java文件，要在最上方加上package class（IDEA一般会自动生成）
2 如果一个类没有 package 语句, 则该类被放到一个默认包中
3 包名需要尽量指定成唯一的名字
导入包中的类：
直接导入
public class testdemo {
public static void main(String[] args) {
java.util.Date date=new java.util.Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
这种导入就需要我们知道，我们调用的类在那个包目录下，而且这样子也很麻烦，在这里作为一个了解就可以。
import语句导入
import java.util.Date;
public class testdemo {
public static void main(String[] args) {
Date date=new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
当我们对Date这个类实例化的时候，我们可以发现，IDEA会自动提示出这个类所在的包，此时我们只需要双击一下java.util（在这里，要特别提一下，不同的包里面的类名是可以一样的，我们语句中时间戳的功能，是在java.util这个包下的Date类实现的，这个问题不需要深究，只需要理解利用import是怎么导入包中的类），这个时候就会自动帮我们导入包中的类。
上面所讲的就是通过import语句导入包中具体类名称，其实也可以使用java.util.*;导入，代码也不会报错
import java.util.*;
public class testdemo {
public static void main(String[] args) {
Date date=new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
这个可以理解是一个通配项，这样子确实会比较方便，也很简单，但是我们并不建议这样子去导入包中的类，最好要具体到类名
import java.util.*;
import java.sql.*;
public class testdemo {
public static void main(String[] args) {
Date date=new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
如果此时导入java.util与java.sql包那么此时Date就会报错，原因就是util与sql包下都有一个Date类，那么此时编译器就懵逼了，就不知道导入的是谁的了，那么此时就需要我们导入具体的一个类名就不会报错了
注意事项：
1 不同与c语言，java在使用通配项的时候，不是把包下的所有类都导入进去，是需要哪一个类，才会使用哪一个类，而c语言是把所有的类全部导入
2 包名必须是小写字母
3 在导入包中的类的时候，要导入具体的类名称，养成良好的编程习惯。
静态导入（了解即可）
使用 import static 可以导入包中的静态的方法和字段.
import static java.lang.System.*;
import static java.lang.Math.*;
public class testdemo {
public static void main(String[] args) {
Date date=new Date();
// 得到一个毫秒级别的时间戳
out.println(date.getTime());
out.println(max(2,3));
}
}
取最大值的时候，如果没有调用使用静态导入就必须得是math.max(2,3)，可以看到system以及math就可以省略掉了，这就是静态导入。
包的访问权限
在java的类与对象中，我们已经初步认识到类中的public与priate访问限定符，包访问权限就是不加任何关键字去修饰，直接定义其类型。访问的范围：只能在同一个包中。
常见的系统包
- java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
- java.lang.reflect:java 反射编程包;
- java.net:进行网络编程开发包。
- java.sql:进行数据库开发的支持包。
- java.util:是java提供的工具程序包。(集合类等) 非常重要
- java.io:I/O编程开发包。
继承
class dog{
public String name;
public int age;
public void eat(){
System.out.println("eat()");
}
}
class bird{
public String name;
public int age;
public void eat(){
System.out.println("eat()");
}
public void fly(){
System.out.println("fly()");
}
}
public class test {
public static void main(String[] args) {
dog dog=new dog();
dog.name="haha";
bird bird=new bird();
bird.name="heihei";
bird.fly();
}
}
在上面这个代码我们可以看到，对于bird以及dog类中都含有共同的字段与方法，那么这个时候我们就可以通过继承来对代码实现重复利用（对代码的共同属性进行抽取）
class animal{
public String name;
public int age;
public void eat(){
System.out.println("eat()");
}
}
class dog extends animal{
}
class bird extends animal{
public void fly(){
System.out.println("fly()");
}
}
public class test {
public static void main(String[] args) {
dog dog=new dog();
dog.name="haha";
bird bird=new bird();
bird.name="heihei";
bird.fly();
}
}
在这里我们可以发现，继承是由关键字extends来引出的，其中dog，bird我们称之为子类，派生类，animal我们称之为父类，基类，超类
继承的语法规则
class 子类 extends 父类 {
}
注意要点：
1 通过关键字extends指定父类
2 java中只能继承一个父类
3 子类会继承父类中所有的字段与方法
4 对于private修饰的字段，子类是不能访问的
5 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用.
6 如果一个类不想被继承，那么可以使用关键字final去修饰这个类
super关键字（重点）
1 super（）帮助父类进行构造
在利用构造方法对子类进行构造时，必须要先帮助父类进行构造
class animal{
public String name;
public int age;
public void eat(){
System.out.println(name+"eat()"+age);
}
public animal(String name,int age){
this.name=name;
this.age=age;
eat();
}
public void func(){
System.out.println("");
}
}
class dog extends animal{
public dog(String name,int age){
super(name,age);//调用父类含有两个参数的构造方法
}
}
class bird extends animal{
public bird(String name,int age){
super(name,age);//调用父类含有两个参数的构造方法
}
public void fly(){
System.out.println("fly()");
}
}
public class test {
public static void main(String[] args) {
dog dog=new dog("haha",10);
bird bird=new bird("heihei",20);
}
}
注意事项：
1 super在帮助子类构造父类的时候，super（）必须处于子类构造方法的第一行
2 super表示父类的实例引用，是依赖于对象的，所以是不能出现在静态方法里面的
2 super.func()调用父类的普通方法
class animal{
public String name;
public int age;
public void eat(){
System.out.println(name+"eat()"+age);
}
public animal(String name,int age){
this.name=name;
this.age=age;
}
public void func(){
System.out.println("");
}
}
class dog extends animal{
public dog(String name,int age){
super(name,age);
super.eat();
}
}
在这个代码中，我们可以看到在子类中可以利用super关键字调用父类普通方法，这里要注意super在调用父类的方法时不能写出方法外面的
3 super.data引用父类实例
这个就是在子类中，通过super关键字去访问父类的字段
super关键字与this关键字的区别：
1 super是在父子类的前提下，作用在子类，在子类里去访问父类的方法与字段，并且要先帮助父类构造方法，必须放在第一行
2 this关键字查找范围在本类中或者是本类中没有就去父类中查找，通过this可以调用本类中的字段（本类中要是没有就会去父类中查找），调用本类中的方法（本类要是没有，就会去父类中查找），也可以在本类调用构造方法，调用构造方法需要放在方法的第一行
protected关键字（重点）
1 在同一个类中
public class time {
protected int val = 99;
public static void main(String[] args) {
time time=new time();
System.out.println(time.val);
}
}
此时代码能够正常执行
2 在同一个包中在不同的类
可以看到test与time是在同一个包底下的不同的类，test是可以访问到protected修饰的val
3 不同包底下的子类
在不同包底下，我们要在子类中导入父类，在进行继承，由于是父子类关系，我们要用super关键字对父类中的实例进行访问（super关键字是不能出现在静态方法中的，因为super是对父类对象的引用，是依赖于对象的，而静态方法是属于类的，不依赖于对象）
4 不同包底下的非子类
很明显这是不能进行访问的
访问权限的总结
结合之前我们前面所讲过的public，private，以及包访问权限，现在所学的protected，我们进行一个总结
private：只能在类的内部使用，外部不能进行访问
public：类的外部与内部，同一个包或者不同包下都能进行访问
default（包访问权限）：只能在同一个包中进行访问
protected：同一个包，同一个类，不同包的父子类之间都可以进行访问，在父子类中要利用super关键字进行访问，不同包的非子类是不能进行访问的
更复杂的继承关系：（了解）
我们刚才所例举的动物中，对于猫也分为很多种，比如国内的猫种以及国外的猫种，国内的猫种又可以分为那几种等还可以继续细分下去，这种继承关系必须要有逻辑上的联系，不能仅仅为了继承而继承。一般而言我们对于这种复杂的继承关系，一般最好不要超过3层
多态：
向上转型（重点)
具体可以看下下列代码
bird bird=new bird(“heihei”,20);
在上面的例子中我们我们知道bird是bird的一个引用，它可以写成下列这种形式
bird bird=new bird(“heihei”,20);
animal bird2 = bird；
//或者写成这个样子
animal bird2 = new bird(“heihei”,20);
此时这种写法就被称作向上转型，也就是父类的引用去引用了子类的对象。
向上转型发生的时机：
1 直接赋值法
这个方法其实就是我们刚才在介绍向上转型的时候所介绍的那个例子。
2 作为返回值
public static void main(String[] args) {
animal animal=func();
}
public static animal func(){
bird bird=new bird("gas",39);
return bird;
}
3 方法的参数
public static void main(String[] args) {
bird bird =new bird("aio",39);
func(bird);
}
public static void func(animal animal){
animal.eat();
}
动态绑定（重点）
发生的条件：
1 发生了向上转型（父类引用引用了子类的对象）
2 通过父类的引用，调用父类与子类同名的覆盖方法
动态绑定也被叫做运行时多态（至于具体什么是多态，在下文会具体介绍），也就是在运行时才确定调用的是子类的eat方法
class animal{
public String name;
public int age;
public void eat(){
System.out.println(name+"eat()"+age);
}
public animal(String name,int age){
this.name=name;
this.age=age;
}
}
class bird extends animal{
public bird(String name,int age){
super(name,age);
}
@Override
public void eat() {
System.out.println(name+"吃");
}
public void fly(){
System.out.println("fly()");
}
}
public class blos {
public static void main(String[] args) {
animal animal=new bird("hsd",34);
animal.eat();
}
}
我们首先可以从main函数入手，可以看到，animal调用用eat方法，可以看到并没有执行父类中的eat方法，而是调用了子类中同名且参数相同，返回值相同的eat方法，此时我们就说发生了动态绑定，而eat方法也被称作覆盖方法，在这个过程我们就说eat发生了重写，并且可以用@override进行标注
静态绑定：
与动态绑定不同，静态绑定在编译时就确定调用了子类的eat方法
public class blos {
public static void main(String[] args) {
duck duck=new duck();
duck.fun("haha");
}
}
class duck{
public void fun(){
System.out.println("无参");
}
public void fun(String name){
System.out.println("一个参数");
}
public void fun(String name,int age){
System.out.println("两个参数");
}
}
当duck调用fun方法时，给fun传了几个参数，就对应调用那个方法，这个时候我们就说发生了静态绑定，可以知道静态绑定则需要发生在重载的情况下，而动态绑定则需要先发生重写。
重写的注意事项
1 被final修饰的方法不能发生重写
2 被private修饰的方法不能重写
3 被static修饰的方法不能重写
4 子类方法的修饰限定符要大于父类的修饰限定符
重写与重载的区别
1 重写的返回值要一样（这里有个特殊情况，就是可以是协变类型也是可以的），重载是与返回值无关的
2 重写与重载的方法名都要相同的
3 重写的方法参数要一致，重载的方法参数要不同（这里的方法参数包括含参种类以及含参的个数）
结语：
在后面的一篇文章中，我们会继续详细的讲解什么是多态，什么是抽象类，什么是接口。希望本篇文章能够对于你有所帮助！