一、java前期准备
1、java介绍
Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的 Java 面向对象程序设计语言和 Java 平台的总称。由 James Gosling和同事们共同研发,并在 1995 年正式推出。
后来 Sun 公司被 Oracle (甲骨文)公司收购,Java 也随之成为 Oracle 公司的产品。
Java分为三个体系:
- JavaSE(J2SE)(Java2 Platform Standard Edition,java平台标准版)
- JavaEE(J2EE)(Java 2 Platform,Enterprise Edition,java平台企业版)
- JavaME(J2ME)(Java 2 Platform Micro Edition,java平台微型版)。
2005 年 6 月,JavaOne 大会召开,SUN 公司公开 Java SE 6。此时,Java 的各种版本已经更名,以取消其中的数字 “2”:J2EE 更名为 Java EE,J2SE 更名为Java SE,J2ME 更名为 Java ME。
- javase是java的标准版,整个java的基础和核心,也是javaee和javame技术的基础,主要用于开发桌面应用程序。
- java用的最多的地方是web应用,javaee就是开发web应用的,javaee也可以叫做j2ee。
- javame是专门为嵌入式电子产品设计的java语言,javame也可以叫做j2me。
二、Java****语言开发环境搭建
1、Java虚拟机**——JVM**
JVM(Java Virtual Machine):Java虚拟机,简称JVM,是运行所有Java程序的假想计算机,是Java程序的 运行环境,是Java最具吸引力的特性之一。我们编写的Java代码,都运行在JVM之上。
跨平台:任何软件的运行,都必须要运行在操作系统之上,而我们用Java编写的软件可以运行在任何的操作系 统上,这个特性称为Java****语言的跨平台特性。该特性是由JVM实现的,我们编写的程序运行在JVM上,而JVM运行在操作系统上。
2、JRE和JDK
JRE(Java Runtime Environment):是Java程序的运行时环境,包含JVM和运行时所需要的核心类库。
JDK(Java Development Kit):是Java程序开发工具包,包含JRE和开发人员使用的工具。
我们想要运行一个已有的Java程序,那么只需安装JRE即可。
我们想要开发一个全新的Java程序,那么必须安装JDK。
jdk下载地址
http://www.oracle.com/technetwork/java/javase/downloads/index.html
安装jdk8(1.8)
jdk安装教程:
https://blog.csdn.net/shengmer/article/details/78836255
步骤:
下载——》安装——》环境配置
3、编译工具IDEA
IDEA安装使用参考我另外一篇文章
https://blog.csdn.net/busiruoli/article/details/115147166
我们创建的项目,在d:\ideawork目录的demo下
- .idea目录和demo.iml和我们开发无关,是IDEA工具自己使用的
- out目录是存储编译后的.class文件
- src目录是存储我们编写的.java源文件
三、简单语法入门
1、最简单的java源文件
新建记事本文件,后缀改成 .java
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
文件名必须是HelloWorld,保证文件名和类的名字是一致的,注意大小写。
每个字母和符号必须与示例代码一模一样。
2、编译、运行
cmd下切换到根目录
编译:
javac Java源文件名.后缀名
例如:
javac HelloWorld.java
执行:
java 类名字
例如:
java HelloWorld
cmd会打印结果。
关于main方法
main****方法:称为主方法。写法是固定格式不可以更改。main方法是程序的入口点或起始点,无论我们编写多少程序,JVM在运行的时候,都会从main方法这里开始执行。
注释comment
单行注释以//开头 换行结束
多行注释以/开头 以/结束
3、关键字****keywords
类别 | 关键字 | 说明 |
---|---|---|
访问控制 | private | 私有的 |
protected | 受保护的 | |
public | 公共的 | |
default | 默认 | |
类、方法和变量修饰符 | abstract | 声明抽象 |
class | 类 | |
extends | 扩充,继承 | |
final | 最终值,不可改变的 | |
implements | 实现(接口) | |
interface | 接口 | |
native | 本地,原生方法(非 Java 实现) | |
new | 新,创建 | |
static | 静态 | |
strictfp | 严格,精准 | |
synchronized | 线程,同步 | |
transient | 短暂 | |
volatile | 易失 | |
程序控制语句 | break | 跳出循环 |
case | 定义一个值以供 switch 选择 | |
continue | 继续 | |
default | 默认 | |
do | 运行 | |
else | 否则 | |
for | 循环 | |
if | 如果 | |
instanceof | 实例 | |
return | 返回 | |
switch | 根据值选择执行 | |
while | 循环 | |
错误处理 | assert | 断言表达式是否为真 |
catch | 捕捉异常 | |
finally | 有没有异常都执行 | |
throw | 抛出一个异常对象 | |
throws | 声明一个异常可能被抛出 | |
try | 捕获异常 | |
包相关 | import | 引入 |
package | 包 | |
基本类型 | boolean | 布尔型 |
byte | 字节型 | |
char | 字符型 | |
double | 双精度浮点 | |
float | 单精度浮点 | |
int | 整型 | |
long | 长整型 | |
short | 短整型 | |
变量引用 | super | 父类,超类 |
this | 本类 | |
void | 无返回值 | |
保留关键字 | goto | 是关键字,但不能使用 |
const | 是关键字,但不能使用 | |
null | 空 |
4、标识符
标识符:是指在程序中,我们自己定义内容。比如类的名字、方法的名字和变量的名字等等,都是标识符。HelloWorld案例中,出现的标识符有类名字HelloWorld。
**命名规则:**硬性要求
- 标识符可以包含英文字母26个(区分大小写)、0-9数字、$(美元符号)和_(下划线)。
- 标识符不能以数字开头。
- 标识符不能是关键字。
**命名规范:**软性建议
- 类名规范:首字母大写,后面每个单词首字母大写(大驼峰式)。
- 方法名规范: 首字母小写,后面每个单词首字母大写(小驼峰式)。
- 变量名规范:全部小写。
5、常量
6、变量
变量定义的格式包括三个要素:数据类型、变量名、数据值。
数据类型 变量名=数据值;
long类型:建议数据后加L表示。
flfloat类型:建议数据后加F表示。
变量名称:在同一个大括号范围内,变量的名字不可以相同。
变量赋值:定义的变量,不赋值不能使用。
7、数据类型转换
7.1、自动转换
- byte类型内存占有1个字节,在和int类型运算时会提升为int类型 ,自动补充3个字节,因此计算后的结果还是int类型。
- 同样道理,当一个int类型变量和一个double变量运算时,int类型将会自动提升为double类型进行运算。
- 范围小的类型向范围大的类型提升,byte、short、char运算时直接提升为int。
byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double
7.2、强制转换
转换格式:
数据类型 变量名=(数据类型)被转数据值;
注意
浮点转成整数,直接取消小数点,可能造成数据损失精度。
int强制转成short砍掉2个字节,可能造成数据丢失。
8、运算符
基本运算符与c无差别:算数运算符 赋值运算符 比较运算符
三元运算符****
计算方式:
数据类型 变量名 = 布尔类型表达式?结果1:结果2
布尔类型表达式结果是true,三元运算符整体结果为结果1,赋值给变量。
布尔类型表达式结果是false,三元运算符整体结果为结果2,赋值给变量。
9、方法/回掉/重载
修饰符 返回值类型 方法名 (参数列表){
代码...
return ;
}
**直接调用:**直接写方法名调用
**赋值调用:**调用方法,在方法前面定义变量,接收方法返回值
输出语句调用:
在输出语句中调用方法,System.out.println(方法名())。
不能用输出语句调用void类型的方法。因为方法执行后没有结果,也就打印不出任何内容。
方法重载:指在同一个类中,允许存在一个以上的同名方法,只要它们的参数列表不同即可,与修饰符和返回值类型无关。
参数列表:个数不同,数据类型不同,顺序不同。
重载方法调用:JVM通过方法的参数列表,调用不同的方法。
简单来说就是同样的方法名称传入不同的参数个数或者类型,都是不同函数。我个人一般不使用。
10、流程控制语句
- if else判断语句
- switch选择语句
- for循环语句
- while循环语句
- do while循环语句
- 跳出语句break,continue
break
使用场景:终止switch或者循环
在选择结构switch语句中
continue
使用场景:结束本次循环,继续下一次的循环
11、数组
11.1 定义方法
方法一
数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
举例:
int[] arr = new int[3];
方法二****
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
举例:
int[] arr = new int[]{1,2,3,4,5};
方式三
数据类型[] 数组名 = {元素1,元素2,元素3...};
举例:
int[] arr = {1,2,3,4,5};
数组定义格式详解:
- 数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
- [] : 表示数组。
- 数组名字:为定义的数组起个变量名,满足标识符规范,可以使用名字操作数组。
- new:关键字,创建数组使用的关键字。
- 数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
- [长度]:数组的长度,表示数组容器中可以存储多少个元素。
- 注意:数组有定长特性,长度一旦指定,不可更改。
11.2数组的访问
数组名[索引]
举例:
int[] arr = {1,2,3,4,5};
int i = arr[0]; //i=1
11.3常见操作
数组越界异常
数组空指针异常
12、常用类
12.1 使用步骤
API(Application Programming Interface),应用程序编程接口。Java API是一本程序员的字典 ;
导包
使用import关键字导包,在类的所有代码之前导包,引入要使用的类型,java.lang包下的所有类无需导入。 格式:
import 包名.类名;
创建对象
数据类型 变量名 = new 数据类型(参数列表);
调用方法
变量名.方法名();
12.2 Scanner类
一个可以解析基本类型和字符串的简单文本扫描器。
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
备注:System.in系统输入指的是通过键盘录入数据。
//1. 导包
import java.util.Scanner;
public class Demo01_Scanner {
public static void main(String[] args) {
//2. 创建键盘录入数据的对象
Scanner sc = new Scanner(System.in);
//3. 接收数据
System.out.println("请录入一个整数:");
int i = sc.nextInt();
//4. 输出数据
System.out.println("i:"+i);
}
}
12.3 Random类
此类的实例用于生成伪随机数。
//1. 导包
import java.util.Random;
public class Demo01_Random
{
public static void main(String[] args)
{
//2. 创建键盘录入数据的对象
Random r = new Random();
for(int i = 0; i < 3; i++)
{
//3. 随机生成一个数据
int number = r.nextInt(10);
//4. 输出数据
System.out.println("number:"+ number);
}
}
}
12.4 ArrayList类
java.util.ArrayList是大小可变的数组的实现,存储在内的数据称为元素。此类提供一些方法来操作内部存储 的元素。ArrayList中可不断添加元素,其大小也自动增长。
public class Test02StudentArrayList {
public static void main(String[] args)
{
//创建学生数组
ArrayList<String> list = new ArrayList<>();
//创建学生对象
String s1 = "曹操";
String s2 = "刘备";
String s3 = "孙权";
//打印学生ArrayList集合
System.out.println(list);
//把学生对象作为元素添加到集合
list.add(s1);
list.add(s2);
list.add(s3);
//打印学生ArrayList集合
System.out.println(list);
}
}
12.5 String类
java.lang.String 类代表字符串。Java程序中所有的字符串文字(例如 “abc” )都可以被看作是实现此类的实 例。类 String 中包括用于检查各个字符串的方法,比如用于比较字符串,搜索字符串,提取子字符串以及创建具有翻 译为大写或小写的所有字符的字符串的副本。
- 字符串不变:字符串的值在创建后不能被更改。
- 因为String对象是不可变的,所以它们可以被共享。
- “abc” 等效于 char[] data={ ‘a’ , ‘b’ , ‘c’ } 。
查看类
- java.lang.String :此类不需要导入。
查看构造方法
- public String() :初始化新创建的 String对象,以使其表示空字符序列。
- public String(char[] value) :通过当前参数中的字符数组来构造新的String。
- public String(byte[] bytes) :通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String。
- public int length () :返回此字符串的长度。
- public String concat (String str) :将指定的字符串连接到该字符串的末尾。
- public char charAt (int index) :返回指定索引处的 char值。
- public int indexOf (String str) :返回指定子字符串第一次出现在该字符串内的索引。
- public String substring (int beginIndex) :返回一个子字符串,从beginIndex开始截取字符串到字符
- 串结尾。
- public String substring (int beginIndex, int endIndex) :返回一个子字符串,从beginIndex到
- endIndex截取字符串。含beginIndex,不含endIndex。
- public char[] toCharArray () :将此字符串转换为新的字符数组。
- public byte[] getBytes () :使用平台的默认字符集将该 String编码转换为新的字节数组。
- public String replace (CharSequence target, CharSequence replacement) :将与target匹配的字符串使
- 用replacement字符串替换。
- public String[] split(String regex) :将此字符串按照给定的regex(规则)拆分为字符串数组。
String s = "aa|bb|cc";
String[] strArray = s.split("|"); // ["aa","bb","cc"]
12.6 static关键字
当 static 修饰成员变量时,该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改 该类变量的值,但也可以在不创建该类的对象的情况下对类变量进行操作。
static 数据类型 变量名;
static 关键字,可以修饰变量、方法和代码块。在使用的过程中,其主要目的还是想在不创建对象的情况 下,去调用方法。下面将介绍两个工具类,来体现static 方法的便利。
12.7 Arrays类
java.util.Arrays 此类包含用来操作数组的各种方法,比如排序和搜索等。其所有方法均为静态方法,调用起来 非常简单。
- public static String toString(int[] a) :返回指定数组内容的字符串表示形式。
- public static void sort(int[] a) :对指定的 int 型数组按数字升序进行排序。
12.7 Math类
java.lang.Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。类似这样的工具 类,其所有方法均为静态方法,并且不会创建对象,调用起来非常简单。
- public static double abs(double a) :返回 double 值的绝对值。
- public static double ceil(double a) :返回大于等于参数的最小的整数。
- public static double floor(double a) :返回小于等于参数最大的整数。
- public static long round(double a) :返回最接近参数的 long。(相当于四舍五入方法)
13 异常
四、面向对象
1、面向对象
Java语言是一种面向对象的程序设计语言,而面向对象思想是一种程序设计思想,我们在面向对象思想的指引下, 使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物,每种事物都具备自己的属性和行为。面 向对象思想就是在计算机程序设计过程中,参照现实中事物,将事物的属性特征、行为特征抽象出来,描述成计算 机事件的设计思想。 它区别于面向过程思想,强调的是通过调用对象的行为来实现功能,而不是自己一步一步的去 操作实现。
public class Test01_Student {
public static void main(String[] args) {
//创建对象格式:类名 对象名 = new 类名();
Student s = new Student();
System.out.println("s:"+s); //cn.itcast.Student@100363
//直接输出成员变量值
System.out.println("姓名:"+s.name); //null
System.out.println("年龄:"+s.age); //0
System.out.println("‐‐‐‐‐‐‐‐‐‐");
//给成员变量赋值
s.name = "赵丽颖";
s.age = 18;
//再次输出成员变量的值
System.out.println("姓名:"+s.name); //赵丽颖
System.out.println("年龄:"+s.age); //18
System.out.println("‐‐‐‐‐‐‐‐‐‐");
//调用成员方法
s.study(); // "好好学习,天天向上"
s.eat(); // "学习饿了要吃饭"
}
成员变量和局部变量区别
在类中的位置不同重点
- 成员变量:类中,方法外
- 局部变量:方法中或者方法声明上(形式参数)
作用范围不一样重点
- 成员变量:类中
- 局部变量:方法中
初始化值的不同重点
- 成员变量:有默认值
- 局部变量:没有默认值。必须先定义,赋值,最后使用
在内存中的位置不同了解
- 成员变量:堆内存
- 局部变量:栈内存
生命周期不同了解
- 成员变量:随着对象的创建而存在,随着对象的消失而消失
- 局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
2、封装
2.1 概述
面向对象编程语言是对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界无法直接操作和修改。 封装可以被认为是一个保护屏障,防止该类的代码和数据被其他类随意访问。要访问该类的数据,必须通过指定的 方式。适当的封装可以让代码更容易理解与维护,也加强了代码的安全性。
原则:将属性隐藏起来,若需要访问某个属性,提供公共方法对其访问。
封装的步骤
1.使用private关键字来修饰成员变量。
2.对需要访问的成员变量,提供对应的一对getXxx方法 、setXxx方法。
2.2 关键字private
private****的关键字含义
- private是一个权限修饰符,代表最小权限。
- 可以修饰成员变量和成员方法。
- 被private修饰后的成员变量和成员方法,只在本类中才能访问。
private的使用格式
public class Student {
private String name;
private int age;
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
}
}
2.3 this****关键字
形参变量名与成员变量名重名,导致成员变量名被隐藏,方法中的变量名,无法访问到成员变量,从而赋值失败。所以,我们只能使用this关键字,来解决这个重名问题。
方法被哪个对象调用,方法中的this就代表那个对象。即谁在调用,this就代表谁。
2.4****封装优化构造方法
无论你与否自定义构造方法,所有的类都有构造方法,因为Java自动提供了一个无参数构造方法, 一旦自己定义了构造方法,Java自动提供的默认无参数构造方法就会失效。
public class Student {
private String name;
private int age;
// 无参数构造方法
public Student() {}
// 有参数构造方法
public Student(String name,int age) {
this.name = name;
this.age = age;
}
}
2.5标准代码——JavaBean
JavaBean是Java语言编写类的一种标准规范。符合JavaBean的类,要求类必须是具体的和公共的,并且具有无参数的构造方法,提供用来操作成员变量的set和get方法。
public class ClassName{
//成员变量
//构造方法
//无参构造方法【必须】
//有参构造方法【建议】
//成员方法
//getXxx()
//setXxx()
}
学生类为例,标准代码如下:
public class Student {
//成员变量
private String name;
private int age;
//构造方法
public Student() {}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
//成员方法
publicvoid setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
publicvoid setAge(int age) {
this.age = age;
}
publicint getAge() {
return age;
}
}
测试类,代码如下:
public class TestStudent {
public static void main(String[] args) {
//无参构造使用
Student s= new Student();
s.setName("章子怡");
s.setAge(18);
System.out.println(s.getName()+"‐‐‐"+s.getAge());
//带参构造使用
Student s2= new Student("郭德纲",18);
System.out.println(s2.getName()+"‐‐‐"+s2.getAge());
}
}
3、继承
3.1extends关键字
继承描述的是事物之间的所属关系,这种关系是: is-a 的关系。例如,图中兔子属于食草动物,食草动物属于动 物。可见,父类更通用,子类更具体。我们通过继承,可以使多种事物之间形成一种关系体系。
定义:
就是子类继承父类的属性和行为,使得子类对象具有与父类相同的属性、相同的行为。子类可以直接 访问父类中的非私有的属性和行为。
class 父类 {
...
}
class 子类 extends 父类 {
...
}
3.2implements关键字
使用 implements 关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔)。
public interface A {
public void eat();
public void sleep();
}
public interface B {
public void show();
}
public class C implements A,B { }
3.3 super关键字
子父类中出现了同名的成员变量时,在子类中需要访问父类中非私有成员变量时,需要使用 super 关键字,修饰 父类成员变量,类似 this 。
super.父类成员变量名
class Animal
{
void eat()
{
System.out.println("animal : eat");
}
}
class Dog extends Animal
{
void eat()
{
System.out.println("dog : eat");
}
void eatTest()
{
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
public class Test
{
public static void main(String[] args)
{
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}
3.4final关键字
final 关键字声明类可以把类定义为不能继承的,即最终类;或者用于修饰方法,该方法不能被子类重写:
声明类:
final class 类名 {//类体}
声明方法:
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
注:实例变量也可以被定义为 final,被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final,但是实例变量并不是 final
4、重写&重载
4.1 重写(Override)
如果子类父类中出现重名的成员方法,这时的访问是一种特殊情况,叫做方法重写(Override)。 方法重写 :子类中出现与父类一模一样的方法时(返回值类型,方法名和参数列表都相同),会出现覆盖效果,也称为重写或者复写。声明不变,重新实现。
重写规则
- 参数列表与被重写方法的参数列表必须完全相同。
- 返回类型与被重写方法的返回类型可以不相同,但是必须是父类返回值的派生类(java5 及更早版本返回类型要一样,java7 及更高版本可以不同)。
- 访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类的一个方法被声明为 public,那么在子类中重写该方法就不能声明为 protected。
- 父类的成员方法只能被它的子类重写。
- 声明为 final 的方法不能被重写。
- 声明为 static 的方法不能被重写,但是能够被再次声明。
- 子类和父类在同一个包中,那么子类可以重写父类所有方法,除了声明为 private 和 final 的方法。
- 子类和父类不在同一个包中,那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
- 重写的方法能够抛出任何非强制异常,无论被重写的方法是否抛出异常。但是,重写的方法不能抛出新的强制性异常,或者比被重写方法声明的更广泛的强制性异常,反之则可以。
- 构造方法不能被重写。
- 如果不能继承一个类,则不能重写该类的方法。
4.2 重载(Overload)
重载(overloading) 是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。
每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。
重载规则:
- 被重载的方法必须改变参数列表(参数个数或类型不一样);
- 被重载的方法可以改变返回类型;
- 被重载的方法可以改变访问修饰符;
- 被重载的方法可以声明新的或更广的检查异常;
- 方法能够在同一个类中或者在一个子类中被重载。
- 无法以返回值类型作为重载函数的区分标准。
5、抽象类:
父类中的方法,被它的子类们重写,子类各自的实现都不尽相同。那么父类的方法声明和方法主体,只有声明还有 意义,而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定,包含抽象方法 的类就是抽象类。
修饰符 abstract 返回值类型 方法名 (参数列表);
public abstract void run();
abstract class 类名字 {
}
public abstract class Animal {
public abstract void run();
}
6、接口
定义,它与定义类方式相似,但是使用 interface 关键字。它也会被编译成.class文件,但一定要明确它并 不是类,而是另外一种引用数据类型。
接口就是一种公共的规范标准
public interface 接口名称 {
// 抽象方法
// 默认方法
// 静态方法
// 私有方法
}
- 抽象方法:使用 abstract 关键字修饰,可以省略,没有方法体。该方法供子类实现使用。
含有默认方法和静态方法
- 默认方法:使用 default 修饰,不可省略,供子类调用或者子类重写。
- 静态方法:使用 static 修饰,供接口直接调用。
含有私有方法和私有静态方法
- 私有方法:使用 private 修饰,供接口中的默认方法或者静态方法调用。
实现
类与接口的关系为实现关系,即类实现接口,该类可以称为接口的实现类,也可以称为接口的子类。实现的动作类 似继承,格式相仿,只是关键字不同,实现使用 implements 关键字。
7、多态
现实中,比如我们按下 F1 键这个动作:
- 如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档;
- 如果当前在 Word 下弹出的就是 Word 帮助;
- 在 Windows 下弹出的就是 Windows 帮助和支持。
同一个事件发生在不同的对象上会产生不同的结果。
多态的优点
-
- 消除类型之间的耦合关系
-
- 可替换性
-
- 可扩充性
-
- 接口性
-
- 灵活性
-
- 简化性
多态存在的三个必要条件
- 继承
- 重写
- 父类引用指向子类对象:Parent p = new Child();
8、类的比较
instanceof是 Java 的一个二元操作符,类似于 ==,>,< 等操作符。
instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例,返回 boolean 的数据类型。
结尾
欢迎评论点赞加关注,我会继续努力的!