08 包_继承

程序员文章站 2022-07-05 14:19:19

1 包继承 1.1 包 1.1.1 为什么会使用包？为了更好的管理同名的类。包就是目录包解决的问题类的同名问题。 [1] 防止命名冲突。 [2] 易于管理包和类。 [3] 更好的保护类、属性、方法。 1.1.2 创建包通过关键字package 创建包，package 一定要出现在类文件的 ......

1 包继承

1.1 包

1.1.1 为什么会使用包？

为了更好的管理同名的类。

包就是目录

包解决的问题---类的同名问题。

[1] 防止命名冲突。

[2] 易于管理包和类。

[3] 更好的保护类、属性、方法。

1.1.2 创建包

通过关键字package 创建包，package 一定要出现在类文件的第一句。

包的命名规则

[1]包名由小写字母组成，不能以圆点开头或结尾

e.g: package sxt;

[2]包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名。如：域名javagroup.net

e.g: package cn.sxt.xxx

[4]包名后续部分依不同机构内部的规范不同而不同

e.g: package cn.sxt.qq.xxx

形式:倒置域名.部门.项目组.xxx

整体原则:保持类路径唯一。

1.1.3 编译带包的类

javac –d <目标目录> <源文件目录> 指定放置生成的类文件的位置

08 包_继承

总结

javac –d 也可以编译没有定义包的类。

如果一个类没有定义任何包，jvm默认分配一个包(defaultpackage)

特殊情况1:

当源文件和编译目标路径不在同一目录下时。

08 包_继承

test01找dog时，从当前目录demo02开始找。

开发工具提供的包解决方案:

[1]人为定义src用于存源文件，人为定义一个bin用于存储.class

[2] 保持源文件中的包和目录一一对应。

08 包_继承

[3] 编译时进入src,从src开始编译。src就是包的开始。

08 包_继承

1.1.1 导入包

import 关键字用于导包。加载类的全路径。

为了使用不在同一包中的类，需要在java程序中使用import关键字导入这个类

import java.util.*; // 导入java.util下的所有类。

package cn.sxt;

import cn.sxt2.dog;
public class test01{
    
    public static void main(string[] args){
        // 此时dog是和test01同一目录的dog
        //dog dog = new dog();
        
        //penguin p = new penguin();
        
        dog dog = new dog();
        dog.showinfo();
    }
}

08 包_继承

在同一个类中可能会导入不同包中的同名类。

import java.util.*;
import java.sql.*;

public class test01{
    public static void main(string[] args){
        date d = new date();
    }
    
}

08 包_继承

解决方法

[1] 指定类时明确类的名称

import java.util.*;
import java.sql.date;

public class test01{
    public static void main(string[] args){
        // date明确指java.sql.date
        date d = new date(0);
        system.out.println(d);
    }

[2]创建对象时明确类名

import java.util.*;
import java.sql.*;

public class test02{
    public static void main(string[] args){
        
        java.util.date d = new java.util.date(0);
        system.out.println(d);
    }
    
}

1.1.1 系统包

包	备注
java.lang(language)	语言级别的包，该包不需要导入，jvm自动加载。
java.util	工具包。
java.io	输入输出流
java.net	网络编程
java.awt	这个包中的类用于构建和管理应用程序的图形用户界面

1.1.1 静态导入

如果一个类中的方法或属性全部是使用static声明，

那么在导入该类的时候就可以使用静态导入的方式

package cn.sxt;

import static cn.sxt.calc.*;
public class test03{
    public static void main(string[] args){
        
        int r = add(1,2);
        system.out.println("pi = "+ pi);
        system.out.println("r = " + r);
    }
}

注意:

修改代码，一定要清理掉之前的.class。

1.1 继承

1.1.1 为什么要使用继承？

08 包_继承

为了减少重复性的代码，在类设计上可以把多个类公共的代码提取到一个公共的类中，这个公共类称为父类(super class)，让这些多个类继承于这个公共父类，这些类称为父类子类（sub class）。

继承的特性

[1] 单继承。java是单继承，只能直接继承一个父类。

[2] 传递性。c继承了b，b继承a。c是a的间接子类，c具有a的特征和行为。

子类继承父类，子类拥有父类的非私有的属性和方法，使用关键字extends实现继承。

同时，子类还可以包含自身特有的属性和方法。

public class test01{
    
    public static void main(string[] args){
        dog dog = new dog();
        dog.color  = "red"; // dog访问父类非私有的属性
        // dog.name = "" // error private访问控制限制
        dog.setname("二狗"); // dog可以访问父类公共的方法
        dog.print(); // dog可以访问父类公共的方法
    }
}

1.1 super

super关键字用于在子类中访问父类成员。

super 只是一个关键字，表示父对象，不存在引用。

[1]访问父类的非私有方法。

public void showinfo(){
        
        system.out.print("我的名称"+super.getname());
        system.out.print(",健康值"+super.gethealth());
        system.out.print(",亲密度"+super.getlove());
        
        system.out.print(",我是一只"+this.getstrain());
    }

[2] 访问父类的非私有属性

public void showinfo(){
        
        // 访问父类非私有属性
        system.out.print(",颜色"+super.color);
        
        system.out.print(",我是一只"+this.getstrain());
}

思考题:pet中定义了非私有color,dog也定义了非私有color。如何在子类访问子类color和父类color？

[3] 访问父类的构造方法

形式:super(参数1,参数2,…)

public dog(string name,int health,int love,string strain){
        
        /*super.setname(name);
        super.sethealth(health);
        super.setlove(love);
        */
        super(name,health,love);
        this.setstrain(strain);
        
    }

08 包_继承

1.1 子类从父类到底继承了什么？

子类不能继承父类的

08 包_继承

1.1 访问修饰符权限

访问修饰符一般用于限制属性、方法、类、接口等的访问权限。java中有4种访问权限。

关键字	本类	同包子类	同包其他类	不同包子类	不同包其他类
public	✔	✔	✔	✔	✔
默认friendly	✔	✔	✔	✘	✘
protected	✔	✔	✔	✔	✘
private	✔	✘	✘	✘	✘

public:公共权限。任何情况都可以访问。权限最大。

protected:受保护的权限。①子类可访问 ②同包可访问

默认(friendly),也称为包访问权限。同包可访问。

private:私有的，本类可访问。

1.2 继承的初始化顺序

08 包_继承

1.1 继承关系的内存图

08 包_继承

思考:

[1] 静态属性和静态方法能不能被继承？

1.1 方法重写(override/overwrite)

1.1.1 重写概念

当子类继承父类的方法不能满足子类需要时，子类可以选择性的重写父类的方法。

// pet    
public void showinfo(){
        system.out.print("我的名称:"+this.getname());
        system.out.print(",健康值:"+this.gethealth());
        system.out.print(",亲密度:"+this.getlove());
}

//dog    
public void showinfo(){
        system.out.print("我的名字:"+getname());
        system.out.print(",健康值:"+super.gethealth());
        system.out.print(",亲密度:"+super.getlove());
        system.out.print(",我是一只:"+this.getstrain());
}

注意:

[1] 重写的一定是方法

[2] 重写一定建立在继承的基础上，没有继承，就没有重写。

子类可以根据自身需要分为完成重写或部分重写。

完全重写：子类继承过来的东西没有任何作用，此时可以完全重写。

public void showinfo(){
        system.out.print("我的名字:"+getname());
        system.out.print(",健康值:"+super.gethealth());
        system.out.print(",亲密度:"+super.getlove());
        system.out.print(",我是一只:"+this.getstrain());
}

部分重写:子类继承过来的东西部分有用，需要子类根据自身特性添加更多的资源。此时可以部分重写。

public void showinfo(){
        super.showinfo();
        system.out.print(",我是一只:"+this.getstrain());
}

1.1.1 重写原则

方法名相同
参数列表相同
返回值类型（父类）相同或者是其子类；
访问权限不能严于父类

// pet.java    
public pet create(){
        system.out.println("宠物生宠物");
        pet p = new pet();
        return p;
    }

// dog.java
public dog create(){
        system.out.println("狗生狗");
        dog d = new dog();
        return d;
}

08 包_继承

1.1 抽象类

1.1.1 抽象类概念

c继承b，b继承a，整个继承过程中，形成一个继承金字塔，位于继承金字塔顶的类越来越简答(抽象)，而位于金字塔底的类，越来越具体(强大)。

位于金字塔顶端的类，根据本身特性过于抽象，我们成这样的类为抽象类(abstract class)

1.1.2 抽象类特性

[1] 抽象类不能实例化，abstract 修饰

public abstract class animal{
    
}

08 包_继承

[2] 抽象方法

在抽象类的一些方法因为类本身过于抽象而无法实现，我们成这些方法为抽象方法(abstract method)

抽象方法一定位于抽象类中。

抽象类中的方法不一定都是抽象方法。

public abstract class animal{
    
    //…

    public abstract void sleep();
    
}

[3] 子类继承了抽象类，一定要实现抽象类中的抽象方法，除非该子类也是抽象类。

public abstract class animal{
    
    public abstract void sleep();
    
}

public abstract class person extends animal{
    
}

public class person extends animal{
    
    public void sleep(){
        system.out.println("人类的sleep方法");
    }
    
}

08 包_继承

1.1.1 重写(override)和实现(implement)

重写:子类继承父类的方法满足不了自身需要时，子类可以重写父类的方法。一般而言，父类的方法已经实现，但不能满足子类需要。

实现:子类继承抽象的父类时，一定要完全重写抽象父类的抽象方法。这个过程称为实现。父类的方法只是一个形式的定义，没有方法体。

实现是一种特殊的重写，一种强制性的重写。

1.1 final

final 关键字表示最终的意思。可以用于修饰类、方法、属性、局部变量等。

[1]final修饰类表示最终类。最终类不能被继承。

public final class animal{
    
}

public class person extends animal{
    
}

08 包_继承

[2]final修饰符方法。最终方法不能被重写。

public class animal{
    
    public final void sleep(){
        
    }
}

public class person extends animal{
    
    public void sleep(){

        system.out.println("person:sleep");
    }
}

08 包_继承

[3] 修饰属性。经常和static配合声明静态常量。

static final string gender_man = “男”;
static final string gender_woman = “女”;

[4] 局部变量

final修饰基本数据类型。变量代表的空间值不能发生变量。

final 修饰引用数据类型。修饰变量表示引用的空间不能发生变化。引用空间中的属性不受final限制。

使用final修饰引用型变量，变量不可以再指向另外的对象

public class test01{
    
    public static void main(string[] args){
        
        final person a;
        
        a = new person();
        a.name = "kallen1";
        a.name = "kallen2";
        system.out.println("a = "+a);
        
        /*
        a = new person();
        system.out.println("a = "+a);
        */
    }
}

思考：

静态方法可以重写吗？

1.1 总结

q:为什么要使用继承？

提取重复性代码，减少代码量

q:何时使用继承

[1] 复合is a关系。

[2] 多个类存在重复性代码

1.2 开发工具

主流:eclipse / idea

下载地址:eclipse.org

1.2.1 快捷键

ctrl++	编辑区字体放大
ctrl+-	编辑区字体缩小
ctrl+1	快速修复代码
ctrl+shift+f	格式化代码
shift+alt+s	source菜单
ctrl+alt+向上/向下	向上/向下快速复制本行代码
ctrl+shift+o	快速导包
alt+向上/向下	快速移动代码

配置eclipse智能提示

08 包_继承

上一篇：都秃了

下一篇： asp.net core 一个中小型项目实战的起手式——项目搭建与仓储模式下的持久层创建（1）

08 包_继承

1 包继承

1.1 包

1.1.1 为什么会使用包？

1.1.2 创建包

1.1.3 编译带包的类

1.1.1 导入包

1.1.1 系统包

1.1.1 静态导入

1.1 继承

1.1.1 为什么要使用继承？

1.1 super

1.1 子类从父类到底继承了什么？

1.1 访问修饰符权限

1.2 继承的初始化顺序

1.1 继承关系的内存图

1.1 方法重写(override/overwrite)

1.1.1 重写概念

1.1.1 重写原则

1.1 抽象类

1.1.1 抽象类概念

1.1.2 抽象类特性

1.1.1 重写(override)和实现(implement)

1.1 final

1.1 总结

1.2 开发工具

1.2.1 快捷键

如何重封装微软 MSI 安装包

JavaScript寄生组合式继承原理与用法分析

JAVA中继承和多态中重名以及与JS的差异

PHP类继承 extends使用介绍

继承和接口的区别在哪里（2者区别和用法分析）

详解Python编程中包的概念与管理

基于将Android工程做成jar包和资源文件的解决方法

Python模块、包(Package)概念与用法分析

重新理解JavaScript的六种继承方式

查看Python安装路径以及安装包路径小技巧

08 包_继承

1 包 继承

1.1 包

1.1.1 为什么会使用包？

1.1.2 创建包

1.1.3 编译带包的类

1.1.1 导入包

1.1.1 系统包

1.1.1 静态导入

1.1 继承

1.1.1 为什么要使用继承？

1.1 super

1.1 子类从父类到底继承了什么？

1.1 访问修饰符权限

1.2 继承的初始化顺序

1.1 继承关系的内存图

1.1 方法重写(override/overwrite)

1.1.1 重写概念

1.1.1 重写原则

1.1 抽象类

1.1.1 抽象类概念

1.1.2 抽象类特性

1.1.1 重写(override)和实现(implement)

1.1 final

1.1 总结

1.2 开发工具

1.2.1 快捷键

如何重封装微软 MSI 安装包

JavaScript寄生组合式继承原理与用法分析

JAVA中继承和多态中重名以及与JS的差异

PHP类继承 extends使用介绍

继承和接口的区别在哪里（2者区别和用法分析）

详解Python编程中包的概念与管理

基于将Android工程做成jar包和资源文件的解决方法

Python模块、包(Package)概念与用法分析

重新理解JavaScript的六种继承方式

查看Python安装路径以及安装包路径小技巧

1 包继承