Java基础篇

Part1 Java语言基础

一、 IT和计算机

1. IT的发展史

	IT业务	代表公司
第一代	大型机	IBM
第二代	PC/Mac机	MS、Apple
第三代	互联网	Goole、Baidu
第四代	移动互联网	Google、Apple、MS、Alibaba、IBM等

移动互联网：就是移动通信和互联网二者结合起来,成力一体。是指互联的接术、平台、商业模式和应用与移动通技术结合并实践的活动的总容。 物联网：利用局部网络或互联网等通信技术把传感器、控制器、机器、人员和物等通过新的联在一起,形成人与物、物与物相联,实现信息化、远程管理控制和智能化的网络。物联网是互联网的延申，它包括互联网及互联网上所有的资源，兼容互联网的所有应用,但物联网中有的元素（所有的设备、资源及通信等)都是个性化和私有化。

2. 操作系统和平台相关性

操作系统：Operating System是管理和控制计算机与软件资源的计算机程序，是直接运行在“裸机”上的最基本的系统软件，任何其他软件都必须在操作系统的支持下才能运行。
平台相关性：我们称能支持程序运行的硬件或软件环境为平台。不同的平台都有其特定的指令格式，也就是说win支持的指令格式和Linux支持的指令格式是不一样的。进而导致了windows的可执行文件不能再Linux平台上运行。反之也不行，把这种情况称为平台相关性。

比如windows系统的exe文件，Mac系统的app文件等等。平台的相关性，应用软件的迁移问题就暴露出来了。

3. 计算机很二

①进制 进制也就是进位制,是人们定的一种进位方法。对于任何一种进制一X进制,就表示某一位置上的数字运算时是x进一位。十进制是逢十进一、十六进测是十六进一、二进数量逢二进一，以此类推。

二进制由两个基本数字0,1组成。规律是逢二进一，计机都使用二进制表示数

八进制:由0、1、2、3、4、5、6、7组成，规律是逢八进一

十进制:由0、1、2、3、4、5、6、7、8、9组成

十六进制就是逢16进1，但我们只有0~9这十个数字，所以我们用A，B，C，D，E，F这六个字母来分别表示10，11，12，13，14，15。字母不区分大小写。

②进制转换进制转换的核心思想是余数定理

③原码、反码和补码 原码反码和补码操作：在计算机内，有符号数有3种表示法：原码、反码、补码。所有的数据运算都是采用补码进行的。正数的原码反码补码都相同，负数稍微复杂。

原码：就是二进制定点表示法，即最高位为符号位，‘0’表示正，其余位表示数值的大小。

反码：负数的反码是对其原码逐位取反，但符号位除外。

补码：负数的补码是在其反码的末位加1。

求反码的时候，最高位是符号位不能改变。正数的符号位是0，负数的符号位是1.

SUN公司和Java

①计算机语言和编程：

什么是计算机语言：

计算机语言(Computer Language)指用于人与计算机之间通讯的语言。计算机语言是人与计算机之间传递信息的媒介。计算机系统最大特征是指令通过一种语言传达给机器。为了使电子计算机进行各种工作，就需要有一套用以编写计算机程序的数字、字符和语法规划，由这些字符和语法规则组成计算机各种指令(或各种语句)。这些就是计算机能接受的语言。计算机语言分类：（语言的发展总是朝着人类更容易理解的方向发展）

1）机器语言：直接用二进制语言表达，指令是用0和1组成的一串代码，它们有一定的位数，并分成若干段，各段的编码表示不同的含义（如0000代表加载（LOAD），0001代表存储（STORE））。

2）汇编语言：使用一些特殊的英文字母和符号串来代替机器语言的二进制码（又称符号语言）,计算机是不认识这些符号的，这就需要一个专门的程序，专门负责将这些符号翻译成二进制数的机器语言，这种翻译程序被称为汇编程序。汇编语言的实质和机器语言是相同的，都是直接对硬件操作，只不过指令采用了英文缩写的标识符，更容易识别和记忆。它同样需要编程者将每一步具体的操作用命令的形式写出来。 3）高级语言：使用一定格式的自然语言进行编写源代码，通过编译器将源代码翻译成计算机直接识别的机器语言，之后再由计算机执行，不直接操作硬件，把繁琐的翻译操作交给编译器来完成。

编程：人与计算机之间交流的过程，称之为编程。

②sun公司和java平台

Java由James Gosling（JAVA之父）和同事们共同研发，并在1995年正式推出。Java最初被称为Oak，是1991年为消费类电子产品的嵌入式芯片而设计的。1995年更名为Java，并重新设计用于开发Internet应用程序。用Java实现的HotJava浏览器（支持Java applet）显示了Java的魅力：跨平台、动态Web、Internet计算。从此，Java被广泛接受并推动了Web的迅速发展，常用的浏览器均支持Javaapplet。另一方面，Java技术也不断更新。Java自面世后就非常流行，发展迅速，对C++语言形成有力冲击。在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。2010年Oracle公司收购Sun Microsystems。

体系： Java分为三个体系，分别为：

Java SE（J2SE，Java2 Platform Standard Edition，标准版）

JavaEE（J2EE，Java 2 Platform, Enterprise Edition，企业版）

Java ME（J2ME，Java 2 Platform Micro Edition，微型版）

二、类型和运算

1、 8种基本数据类型

四种整数类型(byte、short、int、long)：
- byte：8 位，用于表示最小数据单位，如文件中数据，-128~127
- short：16 位，很少用，-32768 ~ 32767
- int：32 位、最常用，-2^31-1~2^31 （21 亿）
- long：64 位、次常用注意事项： int i=5; // 5 叫直接量（或字面量），即直接写出的常数。整数字面量默认都为 int 类型，所以在定义的 long 型数据后面加 L或 l。小于 32 位数的变量，都按 int 结果计算。强转符比数学运算符优先级高。见常量与变量中的例子。
两种浮点数类型(float、double)：
- float：32 位，后缀 F 或 f，1 位符号位，8 位指数，23 位有效尾数。
- double：64 位，最常用，后缀 D 或 d，1 位符号位，11 位指数，52 位有效尾数注意事项：二进制浮点数： 1010100010=101010001.02=10101000.102^10（2次方)=1010100.0102^11(3次方)= . 10101000102^1010(10次方) 尾数： .1010100010 指数：1010 基数：2 浮点数字面量默认都为 double 类型，所以在定义的 float 型数据后面加F 或 f；double 类型可不写后缀，但在小数计算中一定要写 D 或 X.X float 的精度没有 long 高，有效位数（尾数）短。 float 的范围大于 long 指数可以很大。浮点数是不精确的，不能对浮点数进行精确比较。
一种字符类型(char)：
- char：16 位，是整数类型，用单引号括起来的 1 个字符（可以是一个中文字符），使用 Unicode 码代表字符，0~2^16-1（65535）。注意事项：不能为 0个字符。转义字符：\n 换行 \r 回车 \t Tab 字符 " 双引号 \ 表示一个\ 两字符 char 中间用“+”连接，内部先把字符转成 int 类型，再进行加法运算，char 本质就是个数！二进制的，显示的时候，经过“处理”显示为字符。
一种布尔类型(boolean)：true 真和 false 假。

数据类型转换：

满足自动类型转换的条件：

两种类型要兼容：例如数值类型（整形和浮点型）互相兼容

目标类型大于原类型：例如 double型大于int型

float 转double 可以正确转换；

double 转float会出现损失。

你可以这样来定义一个double型的 double d = 0.1; 然而，你不可以通过 float f = 0.1;来定义一个float型的，这是因为默认的小数是double型的要定义一个float型的，有两种方式 float f = 0.1f; 或者 float f = (float)0.1;

java中可以自动隐式转换float为double，但是不能转化double为float。

java在运算时会自动的提升变量的精度来进行运算，double比float精度更高，所以可以自动的从float转化至double再进行运算。其他类型转换也同理，精度低的可以自动向精度高的进行隐式转换。

运算符的优先级：

最高级：小括号（）

最低级：赋值运算符 =

运算符优先级顺序：

算术运算符(+-*/)>关系运算符(>、<、>=、<=、!=)>逻辑运算符（||、&&、！）

位运算符(了解)：<<左移 3<<2=12-->322=12 即3*2^2=12

2、逻辑运算符

"&","&&","|","||" 逻辑运算符用于连接布尔型表达式。在Java中不同于数学的逻辑表达 3<X<5 ,java 中应该写成 x>3 & x<5

"&" 和"&&" 的区别

单个"&",左边无论真假，右边都进行计算。（没有短路功能：两边表达式都执行；当两边表达式都为TRUE，整个表达式为true）

双个"&",左边为假，右边不进行计算。（短路与：当前面条件不成立时，后面不执行；当两边表达式都为TRUE，整个表达式为true）

"|"和"||" 的区别;

单个"|",左边无论真假，右边都进行计算。

双个"|",左边为真，右边不进行计算。

"|"和"&" 做位运算

二进制进行&位运算，只有1&1得1，其他得0，同理可得6&5算出二进制得100，100换成十进制为4

"^"异或运算和"~"反码

任何相同二进制异或运算都得0，1^1=0,0^0=0,不相同的异或运算都得1，1^0=1,0^1=1。同理6^5的011

那么011的十进制是3。提示一个数异或两次变回本身。比如6^5^5的 110，101，101。先得011，再得110所有又变回原来的数值，此技巧可以用来转换数值，不需要第3个变量即可两个变量值互转。

反码：二进制进行反码计算时。1变成0，0变成1。举例子~6,6的二进制是110在机器上补足32位在110之前补码0。那么反码为111.....001，此时的反码减去1得111.....111000，那么原反码减去相减的码得到0000....000111此时的十进制为-7那么加上原来减去的1得到-7+1就是~6了。（这个我也不是很懂。大牛们指正下）

"<<"左移">>"右移">>>"无符号右移

左移：空缺补0，被移除的高位丢弃，空缺位补0，比如32位二进制 0000....00011左移3位变成了0...00011xxx,则xxx补足000即可。规律左移是基数乘以2的移位幂次方，比如3<<2则是322也就是3乘以2的2次幂。

右移：最高位是什么就补什么。高位是1补1，是0就补0.,规律左移是基数除以2的移位幂次方，比如3>>1则是3/2也就是3除以2的1次幂。

无符号右移：无论高位是0还是1都补0

三、方法

1. 方法重载

在同一个类体
方法名相同
参数列表不同：类型不同、参数个数不同、参数顺序不同

四、数组、数组高级

1. 数组初始化

数组必须初始化才能使用，所谓初始化就是给数组元素分配内存，并为每个元素赋值。

初始化数组的两种方式：

静态初始化；

特点：由我们自己来为每一个数组元素设置初始值，而数组的长度由系统决定。

int[] nums=new int[]{1,2,3,4,5};

动态初始化；

**特点：**由我们来设置数组的元素i个数（数组的长度），而每一个数组元素的初始值由系统决定。 int【】 nums=new int【5】；

无论以那种方式初始化数组，一旦初始化完成，数组的长度就固定了。如果要改变必须重新初始化。

NEW关键字；每new一次就开辟一次内存；

int[] nums =new int[5]{1,2,3,4,5}；//写法是错误的，不能同时使用静态初始化和动态初始化。

什么时候使用静态初始化，什么时候使用动态初始化？

当我们事先知道需要存储哪一些数据的时候，选用静态初始化；

当我们事先不知道需要存储哪一些数据的时候，选用动态初始化。

数组是用来存放一组相同类型数据的容器

2. 数组在内存的存储形式

栈区：一般用来存储比较小的数据，开辟的变量空间一般都是在栈区。特点：计算机自动开辟空间，速度快但是小。栈内数据（局部变量等）使用完后，会自动释放空间；

堆区：一般无法自动开辟空间，都是需要手动开辟的，用来存储比较大的数据。特点是堆区空间大，但是速度慢。

数据区：一般用来存储静态变量和全局变量。

代码区：存储二进制程序代码。

3. 访问引用数据类型和基本数据类型的区别

基本数据类型（值传递），值会直接存储在栈区的变量当中。Var a=10;var b=a; a=11;console.log(b);也就是说我们在栈区开辟了两个变量空间a和b。在a和b中都存储了一个10；当a改变为11的时候，他们的空间不是同一个，b的值还是10；

引用数据类型（址传递），变量空间会在栈区开辟，但是值不是直接存储在栈区的，值是在堆区存储的。栈区变量只是存储值的引用（本质是一个地址）；var a={};var b=a;a.name =”liu”;console.log(b);我们发现b里面也有name属性，属性值也是liu。因为a和b都存储了同一个对象的引用，当有一个去对值改变的时候，另一个访问的是同一个空间的值，也会发生改变。

4. 数组是引用数据类型

5. 特例

特例：String是引用数据类型，但是是值传递。

6. 多维数组

数组的语法：数组的元素类型【】 数组名；

二维数组：把一个一维数组作为一个元素，那么此时元素的类型为：int[]

int[][]   arr={{1,2,3,}，{4,5,6,}，{7,8,9}}；

一维数组中的每一个元素都是一个值（基本数据类型和引用数据类型的值）；

二维数组中的每一个元素又是一个一维数组；

三维数组中的每一个元素又是一个二维数组；

严格上说，在java中不存在多维数组的概念，和c语言做区分，一般称之为数组中的数组。

二维数组的初始化：

静态初始化：

int[][]  arr=new int[][]{
{1,2,3}，
{4,5}，
{6}
}

动态初始化：

int[][] arr=new int[3][5];//创建一个长度为3的二维数组，每一个元素（一维数组）的长度为5.		
int[][]  arr=new int[0][5]；//可以创建一个0维数组（没什么意义）。

Part2 面向对象

一、类和对象

同一个源文件只能有一个类使用public修饰，并且源文件名要和public修饰的类名相同。

类是对象的抽象，对象是类的实例

1. 构造方法

2. Static修饰符的特点

static修饰符的成员（字段/方法），随着所在类的加载而加载

当JVM把字节码加载进JVM的时候，static修饰的成员已经在内存中存在了。

优先于对象的存在

对象是手动通过new关键字创建出来的

static修饰的成员被该类型的所有对象所共享

根据该类创建出来的任何对象，都可以访问static成员；

表面上通过对象去访问static成员，其本质依然通过类名访问，和对象没有任何关系（通过反编译看到的）

直接使用类名访问static成员

因为static修饰的成员直接属于类，不属于对象，所以可以直接使用类名访问static成员。

3. 类成员和实例成员

类中的成员有：字段，方法，代码块
类成员：使用static修饰的成员
实例成员：没有使用static修饰的成员
类成员只能访问类成员
实例成员只能访问实例成员
类成员直接属于类，可以通过类来访问static字段和static方法
实例成员只属于对象，通过对象来访问非static字段和static方法（对象其实可以访问类成员，但底层依然是使用的类名访问）
在static方法中，只能调用static成员

4. 类里成员变量、局部变量、类变量的区别

成员变量和局部变量的区别

类变量

static 类对象：属于类--所有对象共享作用域：随着类的加载而加载，随着类的消失而消失访问方式不同：可以通过类名.方法名直接调用，是因为静态成员加载顺序优先于对象静态方法不能访问非静态成员；非静态成员可以直接访问静态方法 --因为静态方法/变量随main主方法优先加载进内存；而非静态成员随着对象的实例化才被加载 ---所以非静态成员调用静态方法/变量时，肯定能在内存找到； ---而反之，静态方法/变量调用非静态成员时，不一定能找到，因为可能它还没被加载也可以理解：静态方法/变量属于这个类，不属于某个方法。

匿名对象

System.out.println(new Teacher().age);//匿名对象：只能使用一次，一般作为参数传递

二、封装

封装的概念有2个，其一是封装，其二是隐藏

1. 什么是封装（面向对象三大特征之一）？

① 把对象的状态和行为看成一个统一的整体，将二者放在一个独立的模块中（类）；

② “信息隐藏”，把不需要让外界知道的信息隐藏起来，尽可能隐藏对象功能实现细节，向外暴露方法，保证外界安全访问功能；把所有的字段使用private私有化，不允许外界访问，把方法使用public修饰，允许外界访问。

把所有数据信息隐藏起来，尽可能隐藏多的功能，只想外暴露便捷的方法以供调用。

2. 封装的好处

①、使调用者正确、方便的使用系统功能，防止调用者随意修改系统属性，

②、提高组件的重用性，

③、达到组件之间的低耦合性（当某一个模块实现发生变化时，只要对外暴露的接口不变，就不会影响到其他模块）

3. 通过什么来实现隐藏和暴露功能呢？

高内聚：把该模块的内部数据，功能细节隐藏在模块内部，不允许外界直接干预。

低耦合：该模块只需要给外界暴露少量功能方法。

4. 权限访问修饰符

封装其实就是让有些类看不到另外一些类里面做了什么事。所以java提供了访问权限修饰符来规定在一个类里面能看到什么，能暴露什么。

5. 访问权限控制

private：表示私有的，表示类访问权限，只能在本类中访问，离开本类之后，就不能直接访问

**不写（缺省）：**表示包私有，表示包（package）访问权限，访问者的包必须和当前定义的包相同才能访问。

**protected：**表示子类访问权限（继承中），同包中的可以访问，即使不同包，但是有继承关系，也可以访问。

**public：**表示全局的，可以公共访问权限，如某个字段/方法，使用了public修饰，则可以在当前项目中任何地方访问。

修饰类：public 缺省 final abstract

修饰成员属性:public protected 缺省 private final static

修饰成员方法:public protected 缺省 private final abstract static

--------------------------------------------------------------------------------------------------------------------------

权限修饰符:public protected 缺省 private

状态修饰符:finnal static

抽象修饰符:abstract

三、继承

1. 什么是继承关系

基于某个父亲对对象的定义加以扩展，而产生新的子类定义，子类可以继承父类原来的某些定义，也可以增加原来父亲所没有的定义，或者覆写父亲中的某些特性。

从面向对象中的角度上说：继承是一种从一般到特殊的关系，是一种is a的关系，即子类是对父类的扩展，是一种特殊的父类，比如：狗是动物的一种特殊情况，狗属于动物。

在java语言中，存在多个类的时候，我们使用“extends”关键字来表示父类和子类的关系。

语法格式：在定义子类的时候表明自己需要拓展于哪一个父类。

public class 子类类名  **extends**  *父类类名*{

	//TODO 编写自己特有的状态和行为；

}

在java中，类与类之间的关系只允许单继承，不允许多继承

也就是说一个类A，只能有一个直接的父亲，不能出现类A同时继承于类B和类C。

但是java中允许多重继承；

在java中，除了Object类之外，每一个类都有一个直接的父亲

比如class Student extends Person{}

我们就说此时Student的直接父亲是Person

问题：class Person{}，此时Person的父类又是谁？

Object类是java语言的根类（老祖宗，任何类都是Object的子类）

class Person{}等价于class Person extends Object{}

Object类要么是一个类直接父亲，要么是一个类间接父亲，（没有爷爷一说）

2. 继承关系的作用

①、解决代码的重复问题

②、真正的作用，表示出一个体系

3.先写父类还是子类

一般的，我们在开发工程中先写多个自定义类，写完之后，发现多个类之间存在共同的代码，此时可以抽取出一个父类，我们以后做开发，都是基于框架/组件来做的，我们是在别人的基础之上，继续做开发。

4. 子类到底继承了父亲的那些成员

（根据访问修饰符来判断）

①、如果父类中的成员使用public修饰，子类继承；

②、如果父亲中的成员使用protected修饰，子类也继承，即使发父亲和子类不在一个包中；

③、如果父类和子类在同一个包中，此时子类可以继承父类中缺省修饰符的成员。

④、如果父亲中的成员，使用private修饰，子类打死都继承不到，因为private只能在本类中访问。

⑤、父类的构造器，子类也不能继承，因为构造器必须和当前的类名相同。

5. 方法覆盖

判断是否覆写方法的必杀技：@Override标签；若方法是覆写方法，在方法前或上贴上该标签，

编译通过，否则报错。

只有方法存在覆盖的概念，字段没有覆盖

方法覆盖解决的问题：当父亲的某一个行为不符合子类具体的特征时，此时子类需要重新定义父类的方法，并重写方法体。

public class Bird extends Animal {

    @Override
    public void action() {
        System.out.println("鸟会飞");
    }
}

6. final关键字

final修饰类：这个类不能被继承（断子绝孙类）

final修饰方法：final修饰方法时，该方法不能被覆盖（重写）

final修饰成员变量：叫常量，只能初始化一次，并且常量名要大写；static和final组合使用叫静态常量

示例：final修饰变量只能初始化一次

final经常和static一起使用来声明常量

关于final的重要知识点

final关键字可以用于成员变量、本地变量、方法以及类。
final成员变量必须在声明的时候初始化或者在构造器中初始化，否则就会报编译错误。
你不能够对final变量再次赋值。
本地变量必须在声明时赋值。
在匿名类中所有变量都必须是final变量。
final方法不能被重写。
final类不能被继承。
final关键字不同于finally关键字，后者用于异常处理。
final关键字容易与finalize()方法搞混，后者是在Object类中定义的方法，是在垃圾回收之前被JVM调用的方法。
接口中声明的所有变量本身是final的。
final和abstract这两个关键字是反相关的，final类就不可能是abstract的。
final方法在编译阶段绑定，称为静态绑定(static binding)。
没有在声明时初始化final变量的称为空白final变量(blank final variable)，它们必须在构造器中初始化，或者调用this()初始化。不这么做的话，编译器会报错“final变量(变量名)需要进行初始化”。
将类、方法、变量声明为final能够提高性能，这样JVM就有机会进行估计，然后优化。
按照Java代码惯例，final变量就是常量，而且通常常量名要大写：

private final int COUNT = 10;

对于集合对象声明为final指的是引用不能被更改，但是你可以向其中增加，删除或者改变内容。譬如：

private final List Loans = new ArrayList();
list.add(“home loan”);  //valid
list.add("personal loan"); //valid
loans = new Vector();  //not valid

四、多态

1. 属性没有多态

2. 构造方法没有多态

3. 多态的前提

要有继承关系(类和类)也可以是实现关系(接口和实现类)，开发中多态一般都指第二种

4. 多态的特点

把子类对象赋给父亲对象，在运行时期会表现出具体的子类特征

五、抽象类

在有继承关系时，父类中的方法基本不会被使用，所以干脆不写实现，写成抽象方法，由子类去实现

1. abstract关键字

abstract修饰类表示抽象类，修饰方法表示抽象方法

2. 非抽象类里不能有抽象方法

3.抽象类里可以有非抽象方法

4.抽象类不能被实例化

因为抽象类里可能有抽象方法，实例化后便可以调用这个抽象方法，而这是没有意义的

5. 抽象类有构造方法

6. 什么时候用抽象类和抽象方法？

当确定子类和方法全都会覆盖父类时，可以把父类写成抽象类

六、接口

1.接口里不能有非抽象方法

java中的接口:

---多个抽象类的抽象就是接口;

---在java中最小的程序单元就是类,接口其实是一个特殊的类.

java中的接口表示规范,用于定义一组抽象方法,表示某一类事物必须具备的功能,要求实现类必须来实现该接口并提供方法实现.

定义接口和定义类语法相同**;[public] interface 接口名{}**

接口起名问题:表示具有某些能力的,有人习惯以able/handle结尾,Walkable表示可以行走的.

有的公司或个人习惯以I打头,表示接口,如 IWalkable

成功编译之后,和类一样,具有一分字节码.

2.接口存在的成员

1)接口中没有构造器 : 所以就扣不能创建对象(不能new), 接口不能定义普通方法

2)接口中定义的成员变量,实质是全局静态常量,默认使用public static final来修饰

3)接口中定义的方法都是公共的抽象方法,默认使用public abstract来修饰

4)接口中定义的内部类都是公共的静态内部类,默认使用public ststic来修饰内部类

特点:接口只能继承接口,不能继承类,且接口支持多继承(类是单继承).

**[修饰符]	interface  接口名  extends  接口1,接口2{}**

标志接口:接口中没有任何的成员,就仅仅是一个接口的定义,就是一个标志,其他的类实现该接口就属于这个家族,我们可以通过第三方代码赋特殊功能予该接口实现类的(不推荐);

常量接口:有人喜欢使用接口来封装多个常量信息,我们称之为常量接口,其目的和常量类相同(不推荐)

abstract如果不写，系统会默认加上abstract;建议手动加上

int num=100;//表示是静态常量，等同于 public static final int num=100;
		      //不写时，系统会默认加上

3.接口的实现关系

接口的实现者:实现类

接口仅仅是定义了某一事物应该具有的某些功能,但是没有提供任何实现.

此时我们得提供类,再让该类去实现接口,并覆盖接口中的方法,从而实现类接口中定义的功能.

接口和实现类之间的关系严格上称之为"实现关系",使用implements来表示.

但是在开发,有时候为了方便也把这个实现类称之为特殊继承关系.

所以可以这样理解:接口是实现类的父类,实现类就是接口的子类,

4.面向接口编程

接口 变量=创建实现类对象;//体现了多态思想

接口和实现类的多态关系才是我们见的最多的.

一个类可以实现多个接口,从而也弥补了累的单继承关系.

[修饰符] class 类名 extends 父类 inplemrnts  接口1,接口2{}

5.接口和抽象类的区别

相同点:

1)都位于继承的顶端,用于被其他继承和实现

2)都不能实例化

3)都可以定义抽象方法,其子类/实现类都必须覆写这些抽象方法.

不同:

1)接口没有构造方法,抽象类有构造方法.

2)抽象类可包含普通方法和抽象方法,接口只能包含抽象方法(java8之前);

3)一个类只能继承一个直接父类 (可能是抽象类),接口是多继承的并且支持一个类实现多个接口(接口弥补了java的单继承).

4)成员变量:接口里默认是public static final,抽象类是默认包权限.

5)方法:接口里默认是public abstract ,抽象类默认识包访问权限.

6)内部类:接口里默认是public static ,抽象类默认是包访问权限.

如果接口和抽象类可以完成相同的功能,尽量使用接口,面向接口编程.

设计模式:接口和抽象类结合使用的(适配器模式)

七、内部类

内部类:类内包含一个类

内部类成员可以访问外部类成员,包括私有

1.普通内部类

内部类成员的调用方法:

2.静态内部类

3.局部内部类

4.匿名内部类

标签：网易云课堂 JAVA 微专业

Java基础篇

Java基础篇

Part1 Java语言基础

一、 IT和计算机

1. IT的发展史

2. 操作系统和平台相关性

3. 计算机很二

二、 类型和运算

1、 8种基本数据类型

2、 逻辑运算符

三、 方法

1. 方法重载

四、 数组、数组高级

1. 数组初始化

2. 数组在内存的存储形式

3. 访问引用数据类型和基本数据类型的区别

4. 数组是引用数据类型

5. 特例

6. 多维数组

Part2 面向对象

一、类和对象

1. 构造方法

2. Static修饰符的特点

3. 类成员和实例成员

4. 类里 成员变量、局部变量、类变量 的区别

二、封装

1. 什么是封装（面向对象三大特征之一）？

2. 封装的好处

3. 通过什么来实现隐藏和暴露功能呢？

4. 权限访问修饰符

5. 访问权限控制

三、 继承

1. 什么是继承关系

2. 继承关系的作用

3.先写父类还是子类

4. 子类到底继承了父亲的那些成员

5. 方法覆盖

6. final关键字

四、 多态

1. 属性没有多态

2. 构造方法没有多态

3. 多态的前提

4. 多态的特点

五、 抽象类

1. abstract关键字

2. 非抽象类里不能有抽象方法

3.抽象类里可以有非抽象方法

4.抽象类不能被实例化

5. 抽象类有构造方法

6. 什么时候用抽象类和抽象方法？

六、 接口

1.接口里不能有非抽象方法

2.接口存在的成员

3.接口的实现关系

4.面向接口编程

5.接口和抽象类的区别

七、内部类

1.普通内部类

2.静态内部类

3.局部内部类

4.匿名内部类

二、类型和运算

2、逻辑运算符

三、方法

四、数组、数组高级

4. 类里成员变量、局部变量、类变量的区别

三、继承

四、多态

五、抽象类

六、接口