之前从头开始学习了一遍Java基础,记录一下,(主要学习途径是观看黑马程序员视频,如果有需要,可以留言。)
Java语言是一种完全面对对象,安全可靠,与平台无关的语言。
Java的跨平台性是指:通过Java语言编写的应用程序在不同的系统平台上都可以运行。
Java跨平台性的原理是:只要在需要运行Java应用程序的操作系统上,先安装一个Java虚拟机(JVM Java Virtual Machine)即可。由JVM来负责Java程序在该系统中的运行。
JRE(Java Runtime Environment)Java的运行环境
包括Java虚拟机(JVM)和Java程序所需的核心类库等,如果需要运行一个开发好的Java程序,计算机只需要安装JRE即可。
JDK(Java Development Kit)Java 开发工具包
JDK是提供给Java开发人员使用的,其中包含了Java的开发工具,也包括了JRE。所以安装了JDK,就不用再单独安装JRE了。
其中包含的开发工具有:编译工具(javac.exe)、打包工具(jar.exe)等
(使用JDK开发完成的java程序,交给JRE去运行。)
JDK、JRE、JVM及其他开发工具包的关系:
配置环境变量:
1.永久设置:
在电脑/属性/高级系统设置/环境变量中,可将常使用的执行文件的目录添加进Path中,如下载好的JDK/bin的路径,若担心多次改变新添的路径,误操作了原来的电脑设置,可新建变量=路径,然后在path中使用%新建变量%来动态获取路径。
2.临时设置:
在dos命令行中使用set path = //*,可临时设置环境变量,但在关闭该dos后该设置失效。
使用dos命令行编译运行java程序的操作流程。
1.将Java代码编写到扩展名为.java的文件中。
2.通过javac命令对该java文件进行编译。
3.通过java命令对生成的class文件进行运行
java命令的寻址规则:
如果未曾设置classpath,则java命令寻找当前目录下的.class文件运行。
如果设置了classpath,则java命令首先寻找classpath下的目标文件,若classpath = *后有‘;’,则若是未能在classpath寻到目标文件,继续到当前目录寻找,若不在classpath后加‘;’,则在classpath中寻找后不再到当前目录寻找。
Path与Classpath的寻找优先级区别:
Path首先在当前目录下寻找目标文件,再到设置的环境变量中寻找。
Classpath首先寻找设置的Classpath,再到当前目录寻找(若classpath的末尾不加‘;’,则不再寻找当前路径)
若是在文件夹中选择了隐藏已知文件扩展名,可能看见的是一个.java实际上该文件却是一个txt文件。
Java中注释:
用于注解说明解释程序的文字就是注释
提高了代码的阅读性
Java中的注释格式
1.单行注释 // …
2.多行注释 /* … /
3.文档注释 /* … /
(注意多行注释要避免嵌套多行注释)
在开始一个编程前,要理好思绪,规划好了再写代码,注意注释不同分块和关键代码。在程序的顶部应是一块分析。
/
需求: …
思路: …
步骤: …
*/
关键字的定义和特点:
定义:被Java语言赋予了特殊含义的单词
特点:关键字中所有字母都为小写
标识符
在程序中自定义的一些名称。
由26个英文字母大小写,数字:0-9 ,符号:_ $组成
定义合法标识符规则:
1.数字不可以开头
2.不可以使用关键字
Java中严格区别大小写。
注意:在起名字的时候,为了提高阅读性,要尽量有意义
编写代码的规范:
包名:多单词组成时所有字母都小写。xxxyyyzzz
类名接口名:多单词组成时,所有单词的首字母大写。XxxYyyZzz
变量名和函数名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写。xxxYyyZzz
常量名:所有字母都大写。多单词时每个单词用下划线连接。XXX_YYY_ZZZ
常量表示不能改变的数值
Java中常量的分类:
1.整数常量,所有整数
2.小数常量,所有小数
3.布尔型常量。较为特有,只有两个数值。True flase
4.字符常量。将一个数字字母或者符号用单引号(‘’)标识
5.字符号常量。将一个或多个字符用双引号标识。
6.Null常量,只有一个数值就是null。
八进制:0-7,满8进1,用0开头表示。
十六进制:0-9,A-F,满16进1,用0x开头表示。
变量的概念:
内存中一个存储区域
该区域有自己的名称(变量名)和类型(数据类型)
该区域的数据可以在同一类型范围内不断变化
为什么要定义变量:
用来不断的存放同一类型的常量,并可以重复使用
Java语言是强类型语言,对于每一种数据都定义了明确的具体数据类型,在内存中分配了不同的内存空间
整数默认:int型,小数默认:double型
不同数据类型运算,内存空间小的向内存空间大的提升,但运算后可能报错损失精度。
Int和float都是四个字节的类型,int+float = float
ASCII码。字符与数字的差异,char类在ASCII中有数字表示,所以char类型支持计算。
运算 范例 结果
自增(前) a = 2 ; b = ++a a = 3 ; b = 3
自增(后) a = 2 ; b = a++ a = 3 ; b = 2
取模运算,负号只关注被模数。
字符串数据和任何数据都是使用+连接,最终都会变成字符串
System.out.print和System.out.println中ln表示换行。
转义字符:通过\来转变后面字母或者符号的含义
\n :换行
\b :退格 相当于backspace
\r :相当于按下回车键 window系统中,回车符是由两个字符表示的:\r\n
\t :制表符。相当于tab键
一个汉字占两个字节,而char型也是占两个字节,所以将汉字赋值给char型是可以的。
short s = 3;
s = s + 2 ; <–> s += 2 ;
s = s + 2 ;编译失败,因为s会被提升为int类型,运算后的结果还是int类型。无法赋值给short类型。
s += 2 ; 编译通过,因为+=运算符在给s赋值时,自动完成了强转操作。
比较运算符的结果都是boolean型,也就是要么是true,要么是false。
逻辑运算符用于连接boolean类型的表达式。
&&跟&的特点:
&:无论左边是true或false,右边都运算。
&&:当左边为false时,右边不运算。
|:两边都参与运算。
||:当左边为true时,右边不运算。
位运算符:
<< 左移:相当于乘以2的倍数
右移:相当于除以2的倍数
移n位,就是对乘以或者除以2的n次幂
位运算的运算速度较快
:最高位补什么由原有数据的最高位值而定。
如果最高位为0,右移后,用0补空位。
如果最高位是1,右移后,用1补空位。: 无论最高位是什么,右移后,都用0补空位。
异或^:不同为1,相同为0.一个数异或一个数两次,结果还是那个数。
(异或可以进行简易的加密)
交换两个变量的值: int n = 3 , m = 8;
方法一:通过第三方变量。
int temp;
temp = n;
n = m;
m = n
方法二:不用第三方变量
n = n + m;
m = n - m;
n = n - m;
(受限于int的最大值,易损失精度)
方法三:
n = n ^ m;
m = n ^ m; // (n^m) ^ m;
n = n ^ m; // (nm)(nm)m
实际开发中使用方法一,易读性高。
十进制转十六进制:
int num = 60;
//获取60的二进制最低4位,通过&15;
int n1 = num & 15;
//要获取下一组四位,将60右移4位。
int temp = 60 >> 4;
//对temp的值进行最低四位的获取。
int n2 = temp & 15;
使用>>>右移,可防止负数补上的有效位无法移光的问题。
三元运算符
(条件表达式)?表达式1:表达式2;
如果条件为true,运算后的结果是表达式1;
如果条件为false,运算后的结果是表达式2;
If else 结构的简写格式:变量 = (条件表达式)?表达式1:表达式2;
三元运算符:
好处:可以简化if else 代码。
弊端:因为是一个运算符,所以运算完必须要有一个结果。
Switch语句特点:
A:switch语句选择的类型只有四种:byte,short,int,char。
B:case之间与default没有顺序,先执行第一个case,没有匹配的case执行default。
C:结束switch语句的两种情况:遇到break或者执行到switch语句结束。
D:如果匹配的case或者default没有对应的break,那么程序会继续向下执行,运行可以执行的语句,直到遇到break或者switch结尾结束。
if和switch语句很像。
具体什么场景下,应用哪个语句呢?
如果判断的具体数值不多,并且符合byte short int char这四种类型。
虽然两个语句都可以使用,建议使用switch语句,因为效率稍高。
其他情况:对区间判断,对结果为boolean类型判断,使用if,if的使用范围更加广泛
While:先判断条件,只有条件满足才执行循环体。
Do while : 先执行循环体,再判断条件,条件满足,再继续执行循环体。
: 无论条件是否满足,循环体至少执行一次。
变量有自己的作用域,对于for来讲,如果将用于控制循环的增量定义在for语句中。For语句执行完毕。该变量在内存中被释放。
For和while可以进行互换,如果需要定义循环增量。用for更为合适。
总结:当要对某些语句执行很多次时,就使用循环结构。
for语句的格式:
for(初始化表达式;循环条件表达式;循环后的操作表达式)
{
执行语句;
}
无限循环的最简单表现形式
1.for(;😉{}
2.while(true){}
流程控制语句
Break(跳出) continue(继续)
Break语句:应用范围:选择结构和循环结构
Continue语句:应用于循环结构。
注:
a.这两个语句离开应用范围,存在是没有意义的。
b.这两个语句单独存在时,下面不能有语句,因为执行不到
c.Continue语句时结束本次循环继续下次循环。
d.标号的出现,可以让这两个语句作用于指定的范围。
Break跳出当前循环(内循环)
函数的定义:函数就是定义在类中的具有特定功能的一段独立小程序。
函数也称为方法。
函数的格式:
修饰符 返回值类型 函数名(参数类型 形参1,参数类型 形式参数2)
{
执行语句;
return 返回值;
}
为了提高代码的复用性,可以对重复的代码进行抽取,定义成一个独立的功能。
主函数是静态的所以也必须调用静态的方法。
函数的特点:
定义函数可以将功能代码进行封装。
便于对该功能进行复用。
函数只有被调用才能执行
函数的出现提高了代码的复用性
对于函数没有具体返回值的情况,返回值类型用关键字void表示,那么该函数中的return语句如果在最后一行可以省略不写。(return;)
注意:
函数中只能调用函数,不可以在函数内部定义函数。
定义函数时,函数的结果应该返回给调用者,交由调用者处理。
函数的重载
重载的概念:在同一个类中,允许存在一个以上的同名函数,只要它们的参数个数或者参数类型不同即可。
重载的特点:与返回值类型无关,只看参数列表。
重载的好处:方便于阅读,优化了程序设计。
重载的使用:当定义的功能相同,但参与运算的未知内容不同。那么,这时就定义一个函数名称以表示其功能,方便阅读,而通过参数列表的不同来区分重载和返回值类型无关。
数组的定义:
概念:同一种类型数据的集合。其实数组就是一个容器。
数组的好处:
可以自动给数组中的元素从0开始编号,方便操作这些元素。
格式:
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
元素类型[] 数组名 = new 元素类型[元素,元素,…];
内存结构
Java程序在运行时,需要在内存中分配空间。为了提高运算效率,对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。
内存分为了五个内存区:堆内存,栈内存,方法区,本地方法区,寄存器
栈内存:用于存储局部变量,当数据使用完,所占空间会自动释放。
堆内存:数组和对象,通过new建立的实例都存放在堆内存中。
每一个实体都有内存地址值。
实体中的变量都有默认初始化值
实体不再被使用,会在不确定的时间内被垃圾回收器回收。
方法区,本地方法区,寄存器
各种数据类型的默认值(default):
int : 0 、 double: 0.0 、float:0.0f 、 boolean:false
ArrayIndexOutOfBoundException:操作数组时,访问到了数组中不存在的角标
NullPointerException:空指针异常,当引用没有任何指向,值为null的情况,该引用还用于操作实体
冒泡排序:相邻的两个元素进行比较,如果符合条件换位。
堆内存操作消耗资源大,可在栈内记录,最后再一起执行。
折半查找,提高效率,但是要求数组有序。
转换进制–查表法:将所有的元素临时存储起来。建立对应关系。
打印出来出来显示是倒序,解决方法
字符数组一经定义,初始化值是’\u0000’相当于空格
数组中的数组—二维数组
格式1: int[][] arr = new int[3][2]
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别是arr[0],arr[1],arr[2]
给第一个一维数组1角标位赋值为78写法是:arr[0][1] = 78
格式2: int[][] arr = new int[3][];
二维数组中有3个一维数组
每个一维数组都是默认初始化值为null
一维数组和二维数组的定义方式
int[] x;
int x[];
Int[][] y;int y[][];int[] y[];
理解面向对象
*面向对象是相对面向过程而言
*面向对象和面向过程都是一种思想
*面向过程
*强调的功能行为
*面向对象
*将功能封装进对象,强调具备了功能的对象
*面向对象是基于面向过程的。
面向过程到面向对象。从执行者到指挥者,从自己实现每一个功能,到寻找一个对象,来完成这些功能。
自己的理解:可以将所有物体都视为对象,每个对象都有自己的功能可以去跟别的对象产生联系,功能可以看作连着两个对象的那条线。这样整个环境就视作一张图,面向过程,关注线,面向对象,关注点。
成员变量与局部变量的不同
作用域不同:成员变量作用于整个类中,局部变量作用于函数或语句中。
在内存中的位置不同:
成员变量在堆内存中,因为对象的存在,才在内存中存在
局部变量,存在栈内存中
允许在本类中创建本类对象。
匿名对象
*匿名对象是对象的简化形式
*匿名对象两张使用情况
*当对对象方法仅进行一次调用的时候
*匿名对象可以作为实际参数进行传递
下一句开始,前一句就成为垃圾了。
匿名对象调用属性没有意义,调用方法有意义
构造函数
特点
1.函数名与类名相同
2.不用定义返回值类型
3.不可以写return语句
作用:
给对象进行初始化
注意:
1.默认构造函数的特点
2.多个构造函数是以重载的形式存在的。
封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
好处:
*将变化隔离
*便于使用
*提高重用性
*提高安全性
封装原则:
*将不需要对外提供的内容都隐藏起来
*把属性都隐藏,提供公共方法对其访问。
类中的属性被直接访问就容易出现安全隐患。
关键字Private:私有,权限修饰符:用于修饰类中的成员(成员变量,成员函数)
私有只在本类中有效
私有仅仅是封装的一种表现形式,并不等于封装
之所以对外提供访问方式,就因为可以在访问方式中加入逻辑判断等语句
对访问的数据进行操作。提高代码的健壮性
对象一建立就会调用与之对应的构造函数
构造函数的作用:可以用于给对象进行初始化。
构造函数的小细节:
当一个类中没有定义构造函数时,那么系统会默认给该类加入一个空参数的构造函数
构造函数和一般方法在写法上有不同
在运行上也有不同
构造函数是在对象一建立就运行,给对象添加对象具备的功能
一个对象建立,构造函数只运行一次
而一般方法可以被该对象执行多次
什么时候定义构造函数?
当分析事物时,该事物存在具备一些特性或者行为,那么将这些内容定义在构造函数中
构造代码块
作用:给对象进行初始化
对象一建立就运行,而且优先于构造函数执行
与构造函数的区别:
构造代码块是给所有对象进行统一初始化。
而构造函数是给对应的对象初始化。
将所有对象的共性写在构造代码块中,构造代码块中定义的是不同对象共性的初始化内容
局部变量在局部范围内屏蔽外部变量
This关键字:是用于区分局部变量和成员变量同名的情况
This代表它所在函数所属对象的引用
简单来说,哪个对象在调用this所在的函数,this就代表哪个对象
This的应用:当定义类中功能时,该函数内部要用到该函数的对象时,这时用this来表示这个对象。
This语句用于构造函数之间的互相调用。
This语句只能定义在构造函数的第一行,因为初始化要先执行。
Static关键字
用于修饰成员(成员变量和成员函数)
被修饰后的成员具备以下特点:
- 随着类的加载而加载
- 优先于对象存在
- 被所有对象所共享
- 可以直接被类名调用
使用注意 - 静态方法只能访问静态成员
- 静态方法中不可以写this.super关键字
- 主函数是静态的
类名调用静态修饰的成员,随着类的消失而消失,说明它的生命周期最长。
成员变量是实例变量
静态的成员变量是类变量
实例变量和类变量的区别:
1.存放位置。
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中
2.生命周期:
类变量生命周期最长,随着类的消失而消失
实例变量生命周期随着对象的消失而消失
静态使用的注意事项:
1.静态方法只能访问静态成员
非静态方法既可以访问静态也可以访问非静态
2.静态方法中不可以定义this,super关键字
因为静态优先于对象存在。所以静态方法中不可以出现this
3.主函数是静态的
主函数:是一个特殊的函数。作为程序的入口,可以被jvm调用
主函数的定义:
Public:代表着该函数访问权限是最大的。
Static:代表着主函数随着类的加载就已经存在了。
Void:主函数没有具体的返回值
Main:不是关键字,但是是一个特殊的单词,可以被jvm识别。
(String[] arr):函数的参数,参数类型是一个数组,该数组中的元素是字符串,字符串的数组。
JVM在调用主函数时,传入的是new String[]
静态有利有弊
利:对对象的共享数据进行单独空间的存储,节省空间。没有必要每一个对象中存储一个。可以直接使用类名调用。
弊:生命周期过长,访问出现局限性(只能访问静态)
什么时候定义静态变量(类变量)呢?
当对象中出现共享数据时(不是共享属性),该数据被静态所修饰,对象中的特有数据要定义成非静态存在堆内存中
什么时候定义静态函数?
当功能内没有访问到非静态数据(对象的特有数据),那么该功能可以定义成静态的。
静态的应用
每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装,以便复用。
虽然可以通过建立ArrayTool的对象使用这些工具方法,对数组进行操作。
发现了问题:
1.对象是用于封装数据的,可是ArrayTool对象并未封装特有数据。
2.操作数组的每一个方法没有用到ArrayTool对象中的特有数据
这时就考虑,让程序更严谨,是不需要对象的。
可以将ArrayTool中的方法都定义成静态的,直接使用类名调用。
将方法都静态后使用,可以方便使用,但是该类,还是可以被其他程序建立对象的,为了更为严谨,强制让该类不能建立对象。
可以将构造函数私有化。
能隐藏的全隐藏起来,减少暴露。
编译说明文档使用javadoc,需要将类设置成public
一个类中默认会有一个空参数的构造函数。
这个默认的构造函数的权限和所属类一致。如果类被public修饰,那么默认的构造函数也带public修饰符。
默认构造函数的权限是随着类的变化而变化的
静态代码块的特点:随着类的加载而执行,只执行一次。
普通代码块,是最常见的代码块,在方法里用一对“{}”扩起来的数据,就是普通的代码块
构造代码块:是在类中直接定义的,用“{}”扩起来的代码。每次调用构造方法前执行,都会先执行构造代码块,给对象初始化的
静态代码块:他在类中的成员位置,用“{}”扩起来的代码,只不过他用了static修饰,且执行一次,并优先于主函数,给类初始化的
构造函数是用于给对应对象初始化的
Person p = new Person(“zhangsan”,20)
这句话都做了什么
1.因为new用到了Person.class所以会找到Person.class文件并加载到内存中
2.执行该类中的static代码块,如果有的话,给Person.class类进行初始化
3.在堆内存中开辟空间,分配内存地址
4.在堆内存中建立对象的特有属性,并进行默认初始化。
5.对属性进行显示初始化
6.对对象进行构造代码块初始化
7.对对象进行对应的构造函数初始化
8.将内存地址赋给栈内存中的p变量
设计模式:解决某一类问题最行之有效的方法
Java中有23种设计模式
单例设计模式:解决一个类在内存中只存在一个对象,想要保证对象唯一
1.为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2.还为了让其他程序可以访问到该类对象,要在本类中,自定义一个对象
3.为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式
使用代码体现
1.将构造函数私有化
2.在类中创建一个本类对象
3.提供一个方法可以获取该对象
这个是先初始化对象,称为:饿汉式
Single类一进内存,就已经创建好对象。
一般使用饿汉式,安全简单,懒汉式多人同时使用方法可能出现问题
继承的作用:
1.提高代码的复用性
2.让类与类之间产生了关系,有了这个关系,才有了多态的特性
Java只支持单继承,不支持多继承
因为多继承容易带来安全隐患,当多个父类中定义了相同功能,当功能内容不同时,子类对象不确定要运行哪一个
但是java保留这种机制,并用另一种体现形式来完成,单继承多实现
java支持多层继承,也就是一个继承体系。
如何使用一个继承体系中的功能呢?
想要使用体系,先查阅体系中父类的描述,因为父类中定义的是该体系中共性功能,通过了解共性功能,就可以知道该体系的基本功能。
那么在具体调用时,要创建最子类的对象。一是因为有可能父类不能创建对象,二是创建子类对象可以使用更多的功能,包括基本的也包括特有的。
那么在具体调用时,要创建最子类的对象,为什么呢?一是因为有可能父类不能创建对象,二是创建子类对象可以使用更多的功能,包括基本的也包括特有的。
总结:查阅父类功能,创建子类对象使用功能。
Super.*父类对象的引用。
子父类出现后,类成员的特点
类中成员:
1.变量
2.函数
3.构造函数
1.变量
子类中出现非私有的同名变量时,
子类要访问本类中的变量,用this
子类要访问父类中的同名变量,用super
Super和this的使用几乎一致
This代表的是本类对象的引用
Super代表的是父类对象的引用
子类可以继承父类的所有属性和方法,但是在父类中被private修饰的属性和方法在子类中不允许访问
2.子父类中的函数
当子类出现和父类一模一样的函数时
当子类对象调用该函数,会运行子类函数的内容
如同父类的函数被覆盖一样
这种情况是函数的另一个特性:重写(覆盖)
当子类继承父类,沿袭父类的功能,到子类中
但是子类虽具备该功能,但是功能的内容和父类不一致,
这时。没有必要定义新功能,而是使用覆盖特殊,保留父类的功能定义,并重写功能内容
覆盖:
1.子类覆盖父类,必须保证子类权限大于等于父类权限,才可以覆盖,否则编译失败
2.静态只能覆盖静态
重载:只看同名函数的参数列表
重写:子父类方法要一模一样
This();Super();调用本类/父类的构造函数
3.子父类的构造函数
在对子类对象进行初始化时,父类的构造函数也会运行
那是因为子类的构造函数默认第一行有一条隐式的语句,super();
super();会访问父类中空参数的构造函数,而且子类中所有的构造函数默认第一行都是super();
为什么子类一定要访问父类的构造函数
因为父类中的数据子类可以直接获取,所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的,
所以子类在对象初始化时,要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数,可以通过手动定义super的构造函数
*super语句要放置在子类构造函数的第一行
构造函数中要么有super语句要么有this语句,只能有一种
子类的实例化过程
结论:子类的所有构造函数,默认都会访问父类中空参数的构造函数
因为子类每一个构造函数内的第一行都有一句隐式的super()
当父类中没有空参数的构造函数时,子类必须手动通过super语句形式来指定要访问父类的构造函数
当然:子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数,
子类中至少有一个构造函数会访问父类中的构造函数
Final关键字
*final可以修饰类,方法,变量
*final修饰的类不可以被继承
*final修饰的方法不可以被覆盖
*final修饰的变量是一个常量,只能被赋值一次
*内部类只能访问被final修饰的局部变量
当多个类中出现相同功能,但是功能主体不同,
这时可以进行向上抽取,这时,只抽取功能定义,而不抽取功能主体。
抽象:
抽象类的特点
1.抽象方法一定在抽象类中
2.抽象方法和抽象类都必须被abstract关键字修饰
3.抽象类不可以用new创建对象,因为调用抽象方法没意义。
4.抽象类中的方法要被使用,必须由子类复写起所有的抽象方法后,建立子类对象调用
如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。
抽象类和一般类没有太大的不同
该如何描述事物,就如何描述事物,只不过,该事物出现了一些看不懂的东西。
这些不确定的部分,也是该事物的功能,需要明确出现。但是无法定义主体。
通过抽象方法来表示
抽象类比一般类多了抽象函数,就是在类中可以定义抽象方法。
抽象类不可以实例化。
特殊:抽象类中可以不定义抽象方法,这样做仅仅是不让该类建立对象。
接口:
格式interface{}
接口中的成员修饰符是固定的:
-成员变量:public static final
-成员函数:public abstract
接口的出现将“多继承”通过另一种形式体现出来,即“多实现”
接口的初期理解可以认为是一个特殊的抽象类,当抽象类中的方法是抽象的,
那么该类可以通过接口的形式来表示。
接口定义时,格式特点:
1.接口中常见定义:常量,抽象方法。
2.接口中的成员都有固定修饰符
常量:public static final (interface中默认自加,可以省略不写 )
方法:public abstract (interface中默认自加,可以省略不写 )
记住:接口中的成员都是public
接口:不可以创建对象,因为有抽象方法。
需要被子类实现,子类对接口中的抽象方法全都覆盖后,子类才可以实例化
否则子类是一个抽象类
接口可以被类多实现,也是对多继承不支持的转换形式。
类与类:继承
类与接口:实现
接口与接口:继承,多继承
接口的特点
*接口是对外暴露的规则
*接口是程序的功能扩展
*接口可以用来多实现
*类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口
*接口与接口之间可以有继承关系
多态:可以理解为事物存在的多种体现形态
1.多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接受自己的子类对象
2.多态的前提
必须是类与类之间有关系,要么继承,要么实现。
通常还有一个前提:存在覆盖
3.多态的好处
多态的出现大大的提高程序的扩展性
4.多态的弊端
提高了扩展性,但是只能使用父类引用访问父类的成员
在多态中成员函数非静态的特点:
在编译时期:参阅引用型变量所属的类中是否有调用方法。如果有,编译通过,如果没有编译失败
在运行时期:参阅对象所属的类中是否有调用方法。
简单总结:成员函数在多态调用时,编译看左边,运行看右边
在多态中,成员变量的特点:
无论编译和运行,都参考左边(引用型变量所属的类)
在多态中,静态成员函数的特点:
无论编译和运行,都参考左边