Java之包,抽象类,接口

目录

导入包

静态导入

将类放入包

常见的系统包

抽象类

语法规则

注意事项:

抽象类的作用

接口

实现多个接口

接口间的继承

接口使用实例

 (法一)实现Comparable接口的compareTo()方法

(法二)实现Comparator比较器的compare()方法

Clonable接口和深拷贝

抽象类和接口的区别


(package) 是组织类的一种方式, 使用包的主要目的是保证类的唯一性.
例如 , 你在代码中写了一个 Test . 然后你的同事也可能写一个 Test . 如果出现两个同名的类 , 就会冲突 , 导致代码不能编译通过.
导入包
Java 中已经提供了很多现成的类供我们使用 . 例如
public class Test {public static void main(String[] args) {java.util.Date date = new java.util.Date();// 得到一个毫秒级别的时间戳System.out.println(date.getTime());}
}
可以使用 java.util.Date 这种方式引入 java.util 这个包中的 Date .
但是这种写法比较麻烦一些 , 可以使用 import 语句导入包 .
如果需要使用 java.util 中的其他类 , 可以使用 import java.util.*
但是我们更建议显式的指定要导入的类名 . 否则还是容易出现冲突的情况
注意事项 : import C++ #include 差别很大 . C++ 必须 #include 来引入其他文件内容 , 但是 Java 不需要 .
import 只是为了写代码的时候更方便 . import 更类似于 C++ namespace using
静态导入

使用 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);}
}
将类放入包

基础规则

在文件的最上方加上一个 package 语句指定该代码在哪个包中 .
包名需要尽量指定成唯一的名字 , 通常会用公司的域名的颠倒形式 ( 例如 com.bit.demo1 ).
包名要和代码路径相匹配 . 例如创建 com.bit.demo1 的包 , 那么会存在一个对应的路径 com/bit/demo1 来存储代码.
如果一个类没有 package 语句 , 则该类被放到一个默认包中 .
常见的系统包
1. java.lang: 系统常用基础类 (String Object), 此包从 JDK1.1 后自动导入。
2. java.lang.reflect:java 反射编程包 ;
3. java.net: 进行网络编程开发包。
4. java.sql: 进行数据库开发的支持包。
5. java.util: java 提供的工具程序包, ( 集合类等 )。 
6. java.io:I/O 编程开发包。
抽象类
语法规则
像这种没有实际工作的方法, 我们可以把它设计成一个 抽象方法 (abstract method) , 包含抽象方法的类我们称为 抽象类(abstract class)。
abstract class Shape {
        abstract public void draw();
}
draw 方法前加上 abstract 关键字 , 表示这是一个抽象方法 . 同时抽象方法没有方法体 ( 没有 { }, 不能执行具体代码).
对于包含抽象方法的类 , 必须加上 abstract 关键字表示这是一个抽象类 .

总结 

1.抽象类是被abstract修饰的
2.被abstract修饰的方法称为抽象方法,该方法可以没有具体的实现。

3.当一个类中含有抽象方法的时候,该类必须使用abstract修饰

4.抽象类当中可以有和普通类一样的成员变量和一样的成员方法

5.抽象类是不可以被实例化的。
6.抽象类既然不能实例化对象那么要抽象类干什么???就是为了被继承。
7.当一个普通的类继承了这个抽象类之后,这个普通类一定要重写这个抽象类当中所有的抽象方法。

8.final和abstract是不同同时存在的,抽象方法不能被private和static修饰!
9.当一个抽象类A不想被一个普通类B继承,此时可以把B这个类变成抽象类,那么再当一个普通类C继承这个抽象类B之后,C要重写B和A里面所有的抽象方法。 

注意事项:
1) 抽象类不能直接实例化
Shape shape = new Shape(); // 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化
2) 抽象方法不能是 private
abstract class Shape { abstract private void draw(); 
} // 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private
3) 抽象类中可以包含其他的非抽象方法 , 也可以包含字段 . 这个非抽象方法和普通方法的规则都是一样的 , 可以被重写 , 也可以被子类直接调用
abstract class Shape { abstract public void draw(); void func() { System.out.println("func"); } 
} 
class Rect extends Shape { ... 
} 
public class Test { public static void main(String[] args) { Shape shape = new Rect(); shape.func(); } 
} // 执行结果
func

4)抽象类不一定有抽象方法,但有抽象方法的类一定是抽象类。

5)抽象类中可以有构造方法,供子类创建对象时,初始化父类的成员变量。

抽象类的作用
抽象类存在的最大意义就是为了被继承 .
抽象类本身不能被实例化 , 要想使用 , 只能创建该抽象类的子类 . 然后让子类重写抽象类中的抽象方法 .
接口
接口是抽象类的更进一步 . 抽象类中还可以包含非抽象方法 , 和字段 . 而接口中包含的方法都是抽象方法 , 字段只能包含静态常量。
语法规则
interface IShape { void draw(); 
} 
class Cycle implements IShape { @Override public void draw() { System.out.println("○"); } 
} 
public class Test { public static void main(String[] args) { IShape shape = new Rect(); shape.draw(); } 
}
1.使用 interface 定义一个接口
2.接口中的方法一定是抽象方法 , 因此可以省略 abstract
3.接口中的方法一定是 public, 因此可以省略 public
4.Cycle 使用 implements 继承接口 . 此时表达的含义不再是 " 扩展 ", 而是 " 实现 "
5.在调用的时候同样可以创建一个接口的引用 , 对应到一个子类的实例 .
6.接口不能单独被实例化

接口中只能包含抽象方法. 对于字段来说, 接口中只能包含静态常量(final static).

interface IShape { void draw(); public static final int num = 10; 
}

 其中的 public, static, final 的关键字都可以省略. 省略后的 num 仍然表示 public 的静态常量。

总结

1.使用interface来定义一个接口
⒉.接口当中的成员变量默认是public static final的,一般情况下我们不写

3.接口当中的成员方法默认是public abstact ,一般情况下我们不写

4.接口当中不可以有普通的方法。
5.Java8开始允许在接口当中定义一个default方法,可以有具体的实现的

6.接口当中的方法如果是static修饰的方法那么是可以有具体的实现的

7.接口不能通过new关键字进行实例化。
8.类和接口之间可以通过关键字implements来实现接口。

9.接口也可以发生向上转型和动态绑定的。
10.当一个类实现接口当中的方法之后,当前类当中的方法不能不加public

11.接口当中不能有构造方法和代码块。
12.一个接口也会产生独立的字节码文件。

实现多个接口

有的时候我们需要让一个类同时继承自多个父类. 这件事情在有些编程语言通过 多继承 的方式来实现的。然而 Java 中只支持单继承, 一个类只能 extends 一个父类. 但是可以同时实现多个接口, 也能达到多继承类似的效果.
现在我们通过类来表示一组动物. 

class Animal { protected String name; public Animal(String name) { this.name = name; } 
}
另外我们再提供一组接口 , 分别表示 " 会飞的 ", " 会跑的 ", " 会游泳的”。
interface IFlying { void fly(); 
} interface IRunning { void run(); 
} interface ISwimming { void swim(); 
}
接下来我们创建几个具体的动物
, 是会跑的 .
class Cat extends Animal implements IRunning { public Cat(String name) { super(name); } @Override public void run() { System.out.println(this.name + "正在用四条腿跑"); } 
}
, 是会游的。
class Fish extends Animal implements ISwimming { public Fish(String name) { super(name); } @Override public void swim() { System.out.println(this.name + "正在用尾巴游泳"); } 
}
青蛙 , 既能跑 , 又能游 ( 两栖动物 )。
class Frog extends Animal implements IRunning, ISwimming { public Frog(String name) { super(name); } @Override public void run() { System.out.println(this.name + "正在往前跳"); } @Override public void swim() { System.out.println(this.name + "正在蹬腿游泳"); } 
}
还有一种神奇的动物 , 水陆空三栖 , 叫做 " 鸭子 "。
class Duck extends Animal implements IRunning, ISwimming, IFlying {public Duck(String name) {super(name);}@Overridepublic void fly() {System.out.println(this.name + "正在用翅膀飞");}@Overridepublic void run() {System.out.println(this.name + "正在用两条腿跑");}@Overridepublic void swim() {System.out.println(this.name + "正在漂在水上");}
}

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口.
继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 .
猫是一种动物, 具有会跑的特性.
青蛙也是一种动物, 既能跑, 也能游泳
鸭子也是一种动物, 既能跑, 也能游, 还能飞

接口间的继承

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.

interface IRunning {void run();
}
interface ISwimming {void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {}
class Frog implements IAmphibious { ...
}
通过接口继承创建一个新的接口 IAmphibious 表示 " 两栖的 ". 此时实现接口创建的 Frog , 就继续要实现 run 方法 , 也需要实现 swim 方法 .
接口使用实例
给对象数组排序
class Student{private String name;private int score;public Student(String name, int score) {this.name = name;this.score = score;}@Overridepublic String toString() {return "[" + this.name + ":" + this.score + "]";}
}public class test {public static void main(String[] args) {Student[] students = new Student[] {new Student("张三", 95),new Student("李四", 96),new Student("王五", 97),new Student("赵六", 92),};Arrays.sort(students);System.out.println(Arrays.toString(students));}
}

运行会发现,抛异常了,原因是我们是对学生对象进行排序的,而非像整数这样显而易见能比大小的,因此我们需要实现Comparable接口,并实现其compareTo()方法。

 (法一)实现Comparable接口的compareTo()方法
class Student implements Comparable<Student>{private String name;private int score;public Student(String name, int score) {this.name = name;this.score = score;}@Overridepublic String toString() {return "[" + this.name + ":" + this.score + "]";}//    @Override
//    public int compareTo(Object o) {
//        Student s=(Student)o;
//        return this.score-s.score;
//    }@Overridepublic int compareTo(Student o) {return this.score-o.score;}
}public class test {public static void main(String[] args) {Student[] students = new Student[] {new Student("张三", 95),new Student("李四", 96),new Student("王五", 97),new Student("赵六", 92),};Arrays.sort(students);System.out.println(Arrays.toString(students));}
}

 运行结果

(法二)实现Comparator比较器的compare()方法
class Student{public String name;public int score;public Student(String name, int score) {this.name = name;this.score = score;}@Overridepublic String toString() {return "[" + this.name + ":" + this.score + "]";}
}class AgeComparator implements Comparator<Student>{@Overridepublic int compare(Student o1, Student o2) {return o1.score-o2.score;}
}class NameComparator implements Comparator<Student>{@Overridepublic int compare(Student o1, Student o2) {return o1.name.compareTo(o2.name);}
}public class test {public static void main(String[] args) {Student student1 = new Student("zhangsan",10);Student student2 = new Student("lisi",15);AgeComparator ageComparator = new AgeComparator();System.out.println(ageComparator.compare(student1, student2));NameComparator nameComparator = new NameComparator();System.out.println(nameComparator.compare(student1,student2));}
}

运行结果

Clonable接口和深拷贝

Java 中内置了一些很有用的接口, Clonable 就是其中之一.
Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常.

class Money{public double money = 19.9;
}class Person implements Cloneable{public int age;public Money m;public Person(int age) {this.age = age;this.m = new Money();}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}@Overridepublic String toString() {return "Person{" +" age=" + age +'}';}
}public class Test2 {public static void main(String[] args) throws CloneNotSupportedException {Person person1 = new Person(10);Person person2 = (Person)person1.clone();System.out.println(person1.m.money);System.out.println(person2.m.money);System.out.println("==========================");person2.m.money = 99.99;System.out.println(person1.m.money);System.out.println(person2.m.money);}
}

运行结果

与我们预期的19.9    99.99不符,显然是因为这里是浅拷贝,因此我们需要对m实现深拷贝。

原因如下图:

实现深拷贝后

class Money implements Cloneable{public double money = 19.9;@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}
class Person implements Cloneable{public int age;public Money m;public Person(int age) {this.age = age;this.m = new Money();}@Overrideprotected Object clone() throws CloneNotSupportedException {Person tmp = (Person) super.clone();tmp.m = (Money) this.m.clone();return tmp;}@Overridepublic String toString() {return "Person{" +" age=" + age +'}';}
}
public class Test2 {public static void main(String[] args) throws CloneNotSupportedException {Person person1 = new Person(10);Person person2 = (Person)person1.clone();System.out.println(person1.m.money);System.out.println(person2.m.money);System.out.println("==========================");person2.m.money = 99.99;System.out.println(person1.m.money);System.out.println(person2.m.money);}
}

运行结果:

实现方法如下图:

抽象类和接口的区别

核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/464403.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【linux】HTTPS 协议原理

1. 了解 HTTPS 协议原理 &#xff08;一&#xff09;认识 HTTPS HTTPS 也是一种应用层协议&#xff0c;是在 HTTP 协议的基础上引入了一个加密层 因为 HTTP协议的内容都是按照文本的方式进行传输的&#xff0c;这个过程中&#xff0c;可能会出现一些篡改的情况 &#xff08;…

sql server 文件备份恢复

备份情况 在备份 lys_log_1324.bak 日志文件前&#xff0c;删除table_1表 现在恢复文件 恢复文件&#xff08;使用norecovery&#xff09; RESTORE DATABASE [lys] FILE Nlys, FILE Nlys_02 FROM DISK ND:\liyuanshuai\lys_filegroup.bak WITH FILE 1, NORECOVERY, …

Docker-安装

操作系统&#xff1a;Ubuntu 20.04.6 LTS 更新apt sudo apt update 删除旧版本docker sudo apt-get remove docker docker-engine docker.io 安装docker sudo apt install docker.io 查看docker版本 docker --version 启动docker 启动docker sudo systemctl start docker 启用…

CM API方式设置YARN队列资源

简述 对于CDH版本我们可以参考Fayson的文章,本次是CDP7.1.7 CM7.4.4 ,下面只演示一个设置队列容量百分比的示例,其他请参考cloudera官网。 获取cookies文件 生成cookies.txt文件 curl -i -k -v -c cookies.txt -u admin:admin http://192.168.242.100:7180/api/v44/clusters …

Openlayers高级交互(18/20):根据feature,将图形适配到最可视化窗口

本示例的目的是介绍如何在vue+openlayers中使用extent,使用feature fit的方式来适配窗口。当加载到页面上几个图形要充分展示在窗口的时候,可以用这种方式来平铺到页面中。 效果图 专栏名称内容介绍Openlayers基础实战 (72篇)专栏提供73篇文章,为小白群体提供基础知识及示…

鸿蒙HarmonyOS开发:给应用添加基础类型通知和进度条类型通知(API 12)

文章目录 一、通知介绍1、通知表现形式2、通知结构3、请求通知授权 二、创建通知1、发布基础类型通知2、发布进度类型通知3、更新通知4、移除通知 三、设置通知通道1、通知通道类型 四、创建通知组五、为通知添加行为意图1、导入模块。2、创建WantAgentInfo信息。4、创建WantAg…

Armv8的安全启动

目录 1. Trust Firmware 2. TF-A启动流程 3. TF-M启动流程 3.1 BL1 3.2 BL2 4.小结 在之前汽车信息安全 -- 再谈车规MCU的安全启动文章里&#xff0c;我们详细描述了TC3xx 、RH850、NXPS32K3的安全启动流程&#xff0c;而在车控类ECU中&#xff0c;我们也基本按照这个流程…

CAN总线学习笔记(1、CAN总线定义)

CAN总线学习笔记&#xff08;1、CAN总线定义&#xff09; 江协科技CAN总线入门教程视频学习笔记 CAN特性 两根通信线&#xff08;CAN_H\CAN_L&#xff09;,两根线&#xff0c;无需工地 差分信号&#xff0c;抗干扰能力强 高速CAN&#xff08;ISO11898&#xff09;&#xff…

【算法】【优选算法】双指针(下)

目录 一、611.有效三⻆形的个数1.1 左右指针解法1.2 暴力解法 二、LCR 179.查找总价格为目标值的两个商品2.1 左右指针解法2.2 暴力解法 三、15.三数之和3.1 左右指针解法3.2 暴力解法 四、18.四数之和4.1 左右指针解法4.2 暴力解法 一、611.有效三⻆形的个数 题目链接&#x…

Docker 镜像体积优化实践:从基础镜像重建到层压缩的全流程指南

​ 由于最近在发布的时候发现docker镜像体积变得越来越大&#xff0c;导致整个打包发布流程变得非常耗时了。所以又接到一个差事&#xff0c;优化最终镜像体积。顺便也记录一下docker镜像体积优化的一些步骤。 大概步骤可以分为以下几个步骤&#xff1a; 重做基础镜像&#x…

路径规划 | ROS中多个路径规划算法可视化与性能对比分析

目录 0 专栏介绍1 引言2 禁用局部规划器3 路径规划定性对比实验3.1 加载路径规划器和可视化插件3.2 设置起点和终点3.3 选择规划器规划3.4 不同规划器对比3.5 路径保存和加载 4 路径规划定量对比实验4.1 计算规划耗时4.2 计算规划长度4.3 计算拓展节点数4.4 计算路径曲率4.5 计…

十四届蓝桥杯STEMA考试Python真题试卷第二套第五题

来源:十四届蓝桥杯STEMA考试Python真题试卷第二套编程第五题 本题属于迷宫类问题,适合用DFS算法解决,解析中给出了Python中 map() 和列表推导式的应用技巧。最后介绍了DFS算法的两种常见实现方式——递归实现、栈实现,应用场景——迷宫类问题、图的连通性、树的遍历、拓朴排…

【CSS】——基础入门常见操作

阿华代码&#xff0c;不是逆风&#xff0c;就是我疯 你们的点赞收藏是我前进最大的动力&#xff01;&#xff01; 希望本文内容能够帮助到你&#xff01;&#xff01; 目录 一&#xff1a;CSS引入 二&#xff1a;CSS对元素进行美化 1&#xff1a;style修饰 2&#xff1a;选…

RV1126-SDK学习之OSD实现原理

RV1126-SDK学习之OSD实现原理 前言 本文简单记录一下我在学习RV1126的SDK当中OSD绘制的原理的过程。 在学习OSD的过程当中&#xff0c;可能需要补充的基础知识&#xff1a; OSD是什么&#xff1f; BMP图像文件格式大致组成&#xff1f; 图像调色&#xff08;Palette&#…

Vehicle OS软件平台解决方案

在智能汽车快速迭代的趋势之下&#xff0c;广义操作系统Vehicle OS应运而生&#xff0c;针对应用软件开发周期缩短和底层硬件迭代速度加快的背景&#xff0c;Vehicle OS将应用软件开发和底层硬件迭代解耦。它降低了迭代工作量并节约成本&#xff0c;用标准化的接口来助力软件定…

Chromium Mojo(IPC)进程通信演示 c++(1)

网上搜索关于mojo教程 多数都是理论 加上翻译谷歌mojo文档的&#xff0c;但是如何自定义两个进程使用mojo通信呢&#xff1f;看下面的完整例子介绍&#xff1a;&#xff08;本人也是参考谷歌代码例子改编而成&#xff09; 本文演示了client.exe和service.exe 通过mojo::Incomin…

sparkSQL面试题

一、查询所有数学课程成绩大于语文课程成绩的学生学号 数据 1,yuwen,43 1,shuxue,55 2,yuwen,77 2,shuxue,88 3,yuwen,98 3,shuxue,65 3,yingyu,88 基本步骤&#xff1a; 进行行转列比较语文与数学的成绩 SQL代码&#xff1a; with t1 as(SELECT id,sum(if(name yuwen,sc…

算法|牛客网华为机试21-30C++

牛客网华为机试 上篇&#xff1a;算法|牛客网华为机试10-20C 文章目录 HJ21 简单密码HJ22 汽水瓶HJ23 删除字符串中出现次数最少的字符HJ24 合唱队HJ25 数据分类处理HJ26 字符串排序HJ27 查找兄弟单词HJ28 素数伴侣HJ29 字符串加解密HJ30 字符串合并处理 HJ21 简单密码 题目描…

浅谈QT中Tab键的切换逻辑

浅谈QT中Tab键的切换逻辑 无意中发现在输入界面中按下Tab键时&#xff0c;没有按照预想的顺序切换焦点事件&#xff0c;如下图所示 这个现象还是很有趣&#xff0c;仔细观察了下&#xff0c;默认的切换顺序是按照控件拖入顺序&#xff0c;那么知道了这个问题想要解决起来就很简…

科研绘图系列:R语言组合连线图和箱线图(linechart+boxplot)

文章目录 介绍加载R包数据数据预处理画图1画图2系统信息介绍 连线图(Line Chart)是一种常用的数据可视化图表,它通过将一系列数据点用直线段连接起来来展示数据随时间或有序类别变化的趋势。以下是连线图可以表示的一些内容: 时间序列数据:展示数据随时间变化的趋势,例如…