文章目录
- 0、前言
- 1. 概述和基本语法
- 2. 面向对象与类的高级属性
0、前言
两个建议:
~去B站找Java的课程学一遍
~看懂了一定要跟着动手做，多做几遍
本文更多的总结类的，不适合新手，新手建议去B站学习。
1. 概述和基本语法
1.1 java语言简介
通常以类的形式组织代码，以对象的思想封装数据。
1.1.1 面向对象
两个基本概念:类、对象
四大特性:封装、继承、多态、抽象
封装的目的:安全、简化
java程序运行的过程:
(1)编译:java文件 ===编译为==》 class文件
(2)运行:由我们的系统去运行class
多态: 父类的引用指向了子类的对象 ，接口的引用指向的实现类的对象
接口: 就是一种规范和标准 抽象:类就是抽象，
对象: 对象就是具体的，是从类模板中实例化出来 关键字，new
1.1.2 健壮性
吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分。 如:指针、内存的申请与释放Java会帮忙去处理
1.1.3 跨平台性
跨平台性: 通过Java语言编写的应用程序在不同的系统平台上都可以运行。
原理: 只要在需要运行 java 应用程序的操作系统上，
先安装一个Java虚拟机 (JVM Java Virtual Machine) 即可。
由JVM来负责Java程序在该系统中的运行。
最终达到了一处编写，导出运行的效果
1.2 核心机制—Java虚拟机
JVM是一个虚拟的计算机，具有指令集并使用不同的存储区域。
负责执行指令，管理数据、内存、寄存器。
1.3 核心机制—垃圾回收
-
1、垃圾回收:将不再使用的内存空间进行回收。
-
2、在 C/C++ 等语言中，由程序员负责回收无用内存。
-
3、
Java 不需要程序员负责回收无用的内存:它提供一种系统级线程跟踪存储空间的分配情况。
并在JVM空闲时，检查并释放那些可被释放的存储空间。
垃圾回收在 Java 程序运行过程中自动进行，
程序员无法精确控制和干预。
1.4 注释
注释是给人看的，机器在解析到注释符时会自动忽略相关的代码。
注释是为了提供程序的可扩展和可维护和可阅读性。
1.4.1 单行注释
格式: //注释文字
1.4.2 多行注释
格式: /*注释文字*/
对于单行和多行注释，被注释的文字，不会被JVM(java虚拟机)解释执行。
多行注释里面不允许有多行注释嵌套。
1.4.3 文档注释
其意义就是说明文档创建作者、时间以及完成的功能。注释符 与 多行注释相同
1.5 关键字
凡是java语言本身定义的字符，被称为关键字
1、关键字的定义和特点
定义:被Java语言赋予了特殊含义，用做专门用途的字符串(单词)
特点:关键字中所有字母都为小写
补充:java语言是强类型编程语言，严格区分变量的类型；
比如：
byte short
double char
true flase
case default
break continue
等等具体不在叙述。
1.6 标识符
定义：
(1)Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
(2)凡是自己可以起名字的地方都叫标识符。
2、定义合法标识符规则:
(1)由26个英文字母大小写，数字:0-9 ，_或 $ 组成。
(2)数字不可以开头。
(3)不可以使用关键字和保留字。
(4)Java中严格区分大小写，长度无限制。
(5)标识符不能包含空格。
注意:在起名字的时，为了提高阅读性，要尽量有意义，“见名知意”。
1.7 命名规范
一、命名的规范
1、包名:多单词组成时所有字母都小写:xxxyyyzzz
2、常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ
3、类名、接口名:多单词组成时，所有单词的首字母大写(大驼峰):XxxYyyZzz
4、变量名、函数名:首单词首字母小写，其后每个单词首字母大写(小驼峰):xxYyyZz
二、命名的规则:
约定俗成、见名知意
1.8 变量
1.8.1 变量的定义
1、变量的概念:
(1)内存中的一个存储区域
(2)该区域有自己的名称(变量名)和类型(数据类型)
(3)Java中每个变量必须先声明(定义数据类型)，后使用
(4)该区域的数据可以在同一类型范围内不断变化
2、定义变量的格式:数据类型 变量名 = 初始化值
3、变量是通过使用变量名来访问这块区域的
4、Java是强类型语言，每个变量必须先声明类型，后使用.
5、使用变量注意:变量的作用域:一对{ }之间有效
1.8.2 变量的分类
对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。
1.8.2.1 按数据类型分类
对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。
1、整数类型 共分为是4种，
分别是byte、short、int、long
- Java各整数类型有固定的表数范围和字段长度，不受具体 OS 的影响，以保证 java 程序的可移植性。
- Java 的整型常量默认为 int 型，声明 long 型常量须后加 ‘l’ 或 ‘L’
2、浮点(小数)类型
2种，分别是float、double
与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体OS的影响。
Java 的浮点型常量默认为 double 型，声明 float 型常量，须后加 ‘f’ 或 ‘F’。
浮点型常量有两种表示形式:
十进制数形式:如:5.12 512.0f .512 (必须有小数点)
科学计数法形式:如:5.12e2 512E2 100E-2
3、字符类型
Java的字符串只能使用单引号包括，不能用双引号
同理，
字符串只能使用双引号包括，不能使用单引号。
4、布尔类型
boolean类型数据只允许取值true和false，
不可以0或非 0 的整数替代true和false，
这点和C语言不同
1.8.2.2 被声明的位置划分
成员变量(属于类):方法外部、类的内部定义的变量
局部变量(属于方法):方法或语句块内部定义的变量
注意:类外面(类对应的大括号外面)不能有变量的声明
1.8.2.3 按所属的数据类型划分
按所属的数据类型划分:
1、基本数据类型变量
2、引用数据类型变量 (除了8八大基本数据类型全部都是引用类型)
基本类型包括：
byte, short, int, long,
char, float, double, Boolean,
没有String
1.8.3 数据类型转换
1.8.3.1 基本数据类型转换
自动类型转换:容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为:
有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
当把任何基本类型的值和字符串值进行连接运算时(+)，基本类型的值将自动转化为字符串类型。
1.8.3.2 强制类型转换
boolean类型不可以转换为其它的数据类型。
1.9 运算符
1.9.1 算数运算符
注意的一点：
除法得到的结果是直接摸出小数部分，仅仅保留整数部分。
想要结果四舍五入的话，需要调用相关对应的API（函数）
1.9.2 赋值运算符
符号: =
扩展赋值运算符: +=, -=, *=, /=, %=
1.9.3 比较运算符
注1:比较运算符的结果都是boolean型，也就是要么是true，要么是false。
注2:比较运算符“==”不能误写成“=” 。
关于 “==” 与 equals 的区别：
“==” 仅仅比较引用地址，不会比较内容。
对于基本数据类型变量来讲，没有引用地址，都在栈中。
所以“==”对于基本数据类型来说，比较的就是值（内容）。
对于引用类型变量，如String类型的变量来说，比较的就是地址。
小结“==”：
基本类型：比较的是值是否相同；
引用类型：比较的是引用是否相同；
equals 本质上就是“ == ”，但是 String、Integer 等重写了equals，
把它变成了值比较，所以一般情况下程序中调用 equals 都是比较的值是否相等。
1.9.4 逻辑运算符
(1)、逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 && x<6 。
(2)、“&”和“&&”的区别:
- 单&时，左边无论真假，右边都进行运算;
- 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
- 和“||”的区别同理，双或时，左边为真，右边不参与运算。
- 异或( ^ )与或( | )的不同之处是:对于 ^ 而言，当左右都为true时，结果为false。
1.9.5 位运算符
位运算是直接对二进制进行运算
1.9.6 三元运算符
格式:
(条件表达式)?表达式1:表达式2;
如果条件为true，运算后的结果是表达式1;
如果条件为false，运算后的结果是表达式2;
1.10 分支结构
1.10.1 if else
1.10.2 switch
假设case的语句中不加“break”，default中的语句也会被执行。
public class test {
public static void main(String[] args) {
int i = 1;
switch (i) {
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
//break;
default:
System.out.println("default");
//break; //default是最后一种可能，所以不用再加“ break ”了。
}
}
}
/*
输出结果：
one
default
*/
default子句是任选的，即可以没有此语句，但是为了程序的健壮性，建议加上。
1.11 循环结构
1.11.1 循环语句
循环语句分类：
for 循环(常用)
while 循环
do/while 循环
1.11.2 for语句
语法格式
for (初始化表达式; 布尔值测试表达式; 更改表达式){
语句或语句块;
}
应用举例
public class ForLoop {
public static void main(String args[]){
int result = 0;
for(int i=1; i<=100; i++) {
result += i;//循环体
}
System.out.println("result=" + result);
}
}
1.11.3 while语句
public class Test {
public static void main(String args[]) {
int a = 1;//循环初始化
while (a < 10) {//布尔表达式，也叫条件判断
System.out.println(a); //循环体
a++;//循环结束条件，也叫迭代 如果没有这个部分，那就成了死循环 }
System.out.println("while循环结束");
} }
1.11.4 do while 语句
区别:
While循环是先判断后执行，而do while 循环是先执行后判断。
也就是说do while循环，不管布尔表达式成不成立，循环体都会执行至少一次的。
1.12 流程控制语句
1.12.1 break
break 语句需求:
break语句用于终止某个语句块的执行
{
......
break;
......
}
break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
label1: { ......
label2: { ......
label3: { ......
break label2;
...... }
} }
1.12.2 continue
continue语句用于跳过某个循环语句块的一次执行
continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
总结:
break 只能用于switch语句和循环语句中。
continue 只能用于循环语句中。
标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
break和continue之后不能有其他的语句，因为程序永远不会执行break 和 continue之后的语句。
1.13 数组
数组是多个相同类型数据的组合，实现对这些数据的统一管理
数组属引用类型，数组型数据是对象(Object)，数组中的每个元素相当于该对象的成员变量
数组中的元素可以是任何数据类型，包括基本类型和引用类型
但前提是需要申明和你存放的数据类型一致。
1.13.1 一维数组
1.13.1.1 一维数组声明
一维数组的声明方式: type var[] 或 type[] var;
例如:
int a[];
int[] a1;
double b[];
Mydate []c; //对象数组
Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如: int a[5]; //非法
1.13.1.2 数组初始化
数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，
其中的每个元素也被按照成员变量同样的方式被隐式初始化。例如:
public class Test {
public static void main(String argv[]){
int a[]= new int[5];
System.out.println(a[3]); //a[3]的默认值为0 }
}
1.13.1.3 创建对象数组
1、数组初始化
动态初始化:数组定义与为数组元素分配空间并赋值的操作分开进行。
1.13.2 多维数组
Java中多维数组被做为数组的数组处理
Java中多维数组的声明和初始化应按从高维到低维的顺序进行
java中多维数组不必须是规则矩阵形式
1.13.2.1 多维数组初始化
- 静态初始化
- 动态初始化
2. 面向对象与类的高级属性
2.1 类与对象
2.1.1 面向对象概念
1. 面向过程
在一个结构体中定义窗口的大小，位置，颜色，背景等属性，
对窗口操作的函数与窗口本身的定义 没有任何关系，如HideWindow，MoveWindow，
MinimizeWindow，这些函数都需要接受一个代表要被操作的窗口参数，
是一种谓语与宾语的关系。中心在实现问题或完成的功能的具体过程中
2. 面向对象
定义窗口时，除了要指定在面向过程中规定的那些属性，如大小，位置，颜色，背景等外，
还要指定该窗口可能具有的动作 ，如隐藏，移动，最小化等。这些函数被调用时，
都是以某个窗口要隐藏，某个窗口要移动的语法格式来使用的 ，这是一种主语与谓语的关系。
重在对象，只需要知道什么对象有什么方法使用即调用即可
3. 面向对象的三大特征
封装 (Encapsulation) 继承 (Inheritance) 多态 (Polymorphism)
2.1.2 面向对象思想
面向对象的编程思想力图使计算机语言中对事物的描述与现实世界中该事物的本来面目尽可能的一致。
类(class)和对象(object)是面向对象方法的核心概念。
类是对一类事物描述，是抽象的、概念上的定义;对象是实际存在的该类事物的每个个体，
因而也称实例(instance)。
类是一个模板，对象是模板的具体实例
2.1.3 类与对象
2.1.4 类的定义
- 声明属性举例
public class Person{
private int age; //声明private变量
age public String name = “Lila”; //声明public变量 name
}
- 声明方法
public class Person{
private int age;
public int getAge() { return age; } //声明方法
getAge public void setAge(int i) { //声明方法setAge
age = i; //将参数i的值赋给类的成员变量age
}
}
//方法有时也称为:成员函数(函数)
一个文件中可以存在多个类，但是只能用一个类被public所修饰
2.1.5 对象的创建与使用
使用 new +构造方法 创建一个新的对象;
使用 “对象名.对象成员” 的方式访问对象成员(包括属性和方法)
类的访问机制:
在一个类中的访问机制:类中的方法可以直接访问类中的成员变量。(有一个例外)
在不同类中的访问机制:先创建要访问类的对象，再用对象访问类中定义的成员。
2.1.6 对象的使用
先创建一个对象：
class Person
{
int age;
void shout()
{
System.out.println(“oh,my god! I am “ + age);
}
}
Person p1 = new Person();
创建新的对象之后,我们就可以使用“ 对象名.对象成员 ”的格式，来访问对象的属性
class TestPerson
{
public static void main(String[] args) {
Person p1 = new Person();
Person p2 =new Person();
p1.age = -30;
p2.shout();
} }
2.1.7 匿名对象
我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象，
如:new Person().shout();
如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
我们经常将匿名对象作为实参传递给一个函数调用。
2.2 信息封装与隐藏
2.2.1 必要性
使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。
应该将legs属性保护起来，防止乱用。保护的方式:信息隐藏
比如出现问题:xb.legs=-1000;
2.2.2 private关键字
Java中通过将数据声明为私有的(private)，再提供公开的(public)方法:
getXXX和setXXX实现对该属性的操作，
以实现下述目的:
隐藏一个类的实现细节;
使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作;
便于修改，增强代码的可维护性;
public class Animal{
private int legs; //将属性legs定义为private，只能被Animal类内部访问
public void setLegs(int i){ //在这里定义方法 eat() 和 move()
if (i != 0 && i != 2 && i != 4){
System.out.println("Wrong number of legs!");
return;
}
legs=i;
}
public int getLegs(){
return legs;
}
}
public class Zoo{
public static void main(String args[]){
Animal xb= new Animal();
xb.setLegs(4); //xb.setLegs(-1000);
xb.legs=-1000; //非法
System.out.println(xb.getLegs());
} }
2.3 构造方法(构造器)
2.3.1 构造器的定义、作用
-
构造方法的特征
它具有与类相同的名称;
它不含返回值;注意:
在构造方法里不含返回值的概念是不同于“void”的，在定义构造方法时加了“void”，
结果这个方法就不再被自动调了 -
构造方法的作用
当一个类的实例对象刚产生时，这个类的构造方法就会被自动调用，
我们可以在这个方法中加入要完成初始化工作的代码。
这就好像我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造方法中加入完成“洗澡”的程序代码，
于是每个“人”一出生就会自动完成“洗澡”，
程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了。
2.3.2 表现形式
功能:创建类的实例时，初始化实例的一组指令。
举例：
public class Animal {
private int legs;
public Animal() {legs = 4; } //构造器
public void setLegs(int i)
{ legs = i; }
public int getLegs(){return legs;}
}
创建Animal类的实例:Animal a=new Animal(); //调用构造器，将legs初始化为4
注意:
构造器的名称必须与类名相同。修饰符:public、private、protected
构造器不是一般的方法，没有返回值(连void也不能写)
2.3.3 默认构造方法
Java语言中，每个类都至少有一个构造方法;
如果类的定义者没有显式的定义任何构造方法，系统将自动提供一个默认的构造方法:
(1)默认构造方法没有参数
(2)默认构造方法没有方法体
(3)默认的构造方法:Animal(){}
所以:不编写构造方法就能用new Xxx()创建类的实例。
Java类中，一旦类的定义者显式定义了一个或多个构造方法，系统将不再提供默认的构造方法;
构造器的主要作用:利用构造器参数初始化对象的属性。
2.5 方法的重载
- 发生在同一类中
- 方法名完全相同
- 和返回类型没有关系
- 参数列表不相同(参数的个数、 类型、顺序)
函数的重载就是在同一个类中允许同时存在一个以上的同名函数，只要它们的参数个数或类型不同即可。
如：
在同一个类中可以定义多个同名方法—方法名重载(overload)
重载方法的参数列表必须不同
重载方法的返回值类型可以相同，也可以不同
调用时根据方法的参数类型来区别。
print(3);print(1.2f);print(“hello!”);
2.5.1 构造方法重载
public class Person {
private String name;
private int age;
private Date birthDate;
public Person(String name, int age, Date d) {
this.name = name;
this.age = age;
this.birthDate = d;
}
public Person(String name, int age) {
this(name, age, null); //this.name=name; this.age=age;
//this.birthDate=null;
}
public Person(String name, Date d) {
this(name, 30, d); //this.name=name;
this.age=30;this.birthDate=d;
}
public Person(String name) {
this(name, 30); //this.name=name; this.age=30;
} }
2.6 this关键字
每个成员方法内部，都有一个this引用变量，指向调用这个方法 的对象，
2.7 import语句与package语句
2.7.1package
思想:大量的调用三方API,能自己不写就不写。
package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。
(若缺省该语句，则指定 为无名包)。
如：
2.7.2 import 语句
为使用定义在不同包中的Java类，需用import语句来引入所需要的类。
Import语句告诉编译器到哪里去寻找类。
如：
2.8 类的继承
父类:为描述和处理个人信息，定义类Person
子类:为描述和处理学生信息，定义类Student
Java只支持单继承，不允许多重继承
一个子类只能有一个父类，一个父类可以派生出多个子类
关于继承的规则:
子类不能继承父类中私有的(private)的成员变量和方法。
通过继承，简化Student类的定义:
2.9 访问控制
可以对Java类中定义的属性和方法进行访问控制----规定不同的保护等级:
public、protected、 default、private
2.10 方法的重写
发生在父类和子类之间、方法相同(返回值类型，参数列表，方法名称)，只有方法体不一样才可以
- 在子类中可以根据需要对从父类中继承来的方法进行改造—覆盖方法(方法的重置、重写)，在程序 执行时，子类的方法将覆盖父类的方法。
- 覆盖方法必须和被覆盖方法具有相同的方法名称、参数列表和返回值类型。
- 覆盖方法不能使用比被覆盖方法更严格的访问权限。
2.11 super关键字
关键字super 代表父对象，在Java类中使用super来引用父类的成分
-
super可用于访问父类中定义的属性
-
super可用于调用父类中定义的成员方法
-
super可用于在子类构造方法中调用父类的构造方法
-
super的追溯不仅限于直接父类
-
构造方法不能继承
子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法
在一个Java类中可以通过两种方式获得构造方法
~使用系统默认的无参数构造方法
~显式定义一个或多个构造方法
但是一旦显式定义了构造方法，则系统不再提供默认构造方法 -
调用父类构造方法
在子类的构造方法中可使用super(参数列表)语句调用父类的构造方法，
如果子类的构造方法中没有显示地调用父类构造方法，也没有使用this关键字调用重载的其它构造方法，
则系统默认调用父类无参数的构造方法，如果子类构造方法中既未显示调用父类构造方法，
而父类中又没有无参的构造方法，则编译出错
2.12 多态性
- 在Java中，子类的对象可以替代父类的对象使用
- 一个变量只能有一种确定的数据类型
- 一个引用类型变量可能指向(引用)多种不同类型的对象
Person p = new Student();
Object o = new Person();//Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象
- 父类类型的变量可以指向子类的对象（ 即Person e = new Student(); ）
一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，
那么该变量就不能再访问子类中添加的属性和方法
Student m = new Student();
m.school = “pku”; //合法,Student类有school成员变量 Person e = new Student();
e.school = “pku”; //非法,Person类没有school成员变量
属性是在编译时确定的，编译时e为Person类型，没有school成员变量， 因而编译错误。
1、正常的方法调用
Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();
2、虚拟方法调用(多态情况下)
Person e = new Student();
e.getInfo(); //调用Student类的getInfo()方法
编译时e为Person类型，而方法的调用是在运行时确定的，
所以调用的是Student类的getInfo()方法(动态绑定)
编译看左边，执行看右边
2.13 instance操作符
x instanceof A:检验x是否为类A的对象，返回值为boolean型。
要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
如果x属于类A的子类B，x instanceof A值也为true。
2.14 对象类型转换(Casting)
2.14.1 基本数据类型
- 小的数据类型可以自动转换成大的数据类型，如long g=20; double d=12.0f
- 可以把大的数据类型强制转换(casting)成小的数据类型。如 floate f=(float)12.0; int a=(int)1200L
2.14.2 对Java对象的强制类型转换称为造型
- 从子类到父类的类型转换可以自动进行
- 从父类到子类的类型转换必须通过造型(强制类型转换)实现
- 无继承关系的引用类型间的转换是非法的
- 在造型前可以使用instanceof操作符测试一个对象的类型
2.15 Object类
Object类是所有Java类的根父类
如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类
2.16 equals方法与==
参考上边：1.9.3 比较运算符
2.17 toString
- toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。
- 在进行String与其它类型数据的连接操作时，自动调用toString()方法
-
基本类型数据转换为String类型时，调用了对应封装类的 toString()方法int a=10;
System.out.println(“a=”+a);
2.18 封装类
针对八种基本定义相应的引用类型—封装类
2.19 static关键字
- Java类中声明变量、方法和内部类时，可使用关键字static做为修饰符。
- static标记的变量或方法由整个类(所有实例)共享，如访问控制权限允许，可不必创建该类对象而直 接用类名加‘.’调用。
- static成员也称类成员或静态成员，如:类变量、类方法、静态方法等。
类属性、类方法的设计思想: - 类属性作为该类各个对象之间共享的变量。在设计类时,分析哪些类属性不因对象的不同而改变，将 这些属性设置为类属性。相应的方法设置为类方法。
- 如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方 法，从而简化了方法的调用
2.20 final关键字
-
在Java中声明类、属性和方法时，可使用关键字final来修饰。
-
final标记的变量(成员变量或局部变量)即成为常量，只能赋值一次。
-
final标记的类不能被继承。提高安全性，提高程序的可读性。
-
final标记的方法不能被子类重写。增加安全性。
-
final标记的成员变量必须在声明的同时或在每个构造方法中显式赋值，然后才能使用。
final PI=3.14;
如：
2.20 抽象类
- 随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应 该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这 样的类叫做抽象类。
- 用abstract关键字来修饰一个类时，这个类叫做抽象类;用abstract来修饰一个方法时，该方法叫抽象方法
- 抽象方法:只有方法的声明，没有方法的实现。以分号结束。
- abstract int abstractMethod1( int a );
- 含有抽象方法的类必须被声明为抽象类。
- 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体
- 不能用abstract修饰私有方法，构造方法，静态方法。
2.21 接口(interface)
1、接口的定义
有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。
但是，Java不支持多重继承。 有了接口，就可以得到多重继承的效果。
接口(interface)是抽象方法和常量值的定义的集合。 从本质上讲，接口是一种特殊的抽象类，
这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
2、接口定义举例
3、接口特点:
- 用 interface 来定义。
接口中的所有成员变量都默认是由public static final修饰的。- 接口中的所有方法都默认是由public abstract修饰的。接口没有构造方法。
- 实现接口的类中必须提供接口中所有方法的具体实现内容。
- 多个无关的类可以实现同一个接口
- 一个类可以实现多个无关的接口
- 与继承关系类似，接口与实现类之间存在多态性
- 接口也可以继承另一个接口，使用extends关键字。
4、 接口要求:
- 实现接口的类中必须提供接口中所有方法的具体实现内容。
- 多个无关的类可以实现同一个接口
- 一个类可以实现多个无关的接口
- 与继承关系类似，接口与实现类之间存在多态性
其他的：
- 如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类。
- 接口也可以继承另一个接口，使用extends关键字。