JAVA基础
一、Java语法
1.Java开发环境
java编译运行过程：
编译期：.java源文件，经过编译，生成.class字节码文件
运行期：JVM加载.class并运行.class(0和1)
特点：跨平台，一次编译到处运行
名词解释：
JVM：java虚拟机
加载.class并运行.class
JRE：java运行环境
除了包含JVM以外还包含了运行java程序所必须的环境
JRE = JVM+java系统类库(小零件)
JDK：java开发工具包
除了包含JRE以外还包含了开发java程序所必须的命令工具
JDK = JRE+编译、运行等命令工具
说明：
- 运行java程序的最小环境为JRE
- 开发java程序的最小环境为JDK
idea：
是JetBrains公司的，分为社区版(免费的)和终级版(收费的)
开发步骤：
- 新建Java项目/工程--------------------------小区
- 新建Java包------------------------------------楼+单元
- 新建Java类------------------------------------房子
注释：解释性文本(计算机是不执行的)
- 单行注释：//
- 多行注释：/* */ ------------------------明天讲
- 文档注释：/** */ -----------------------面向对象时讲
IDE：集成开发环境，一整套带图形界面的功能强大的工具，常见的有idea和eclipse
Java：以前说是Sun公司的，现在Sun已经被Oracle收购了，所以我们说java是Oracle公司的
2.变量：存数的
- 声明：------------在银行开了个帐户
- 初始化：------------给帐户存钱
- 使用：---------------使用的是帐户里面的钱
- 对变量的使用就是对它所存的那个数的使用
- 变量在使用之前必须声明并初始化
- 命名：
- 只能包含字母、数字、_和$符，不能以数字开头
- 严格区分大小写
- 不能使用关键字
- 允许中文命名，但不建议，建议"英文的见名知意"、"小驼峰命名法"
3.基本数据类型
byte、short、int、long、float、double、boolean、char
int：整型，4个字节，-21多亿到21个多亿
- 整数直接量默认为int类型，但不能超出范围，若超范围则发生编译错误
- 运算时若超出范围，则发生溢出，溢出不是错误，但需要避免
- 两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)
long：长整型，8个字节，很大很大很大
- 长整型直接量需在数字后加L或l
- 运算时若有可能溢出，建议在第1个数字后加L
double：浮点型，8个字节，很大很大很大
- 浮点数直接量默认为double类型，若想表示float，需在数字后加F或f
- double和float型数据参与运算时，有可能会发生舍入误差，精确场合不能使用
boolean：布尔型，1个字节
- 只能取值为true或false
char：字符型，2个字节
采用的是Unicode编码格式，每个字符都对应一个码
表现的形式为字符char，但本质上是码int(0到65535之间)
ASCII码：'a'----97 ‘A'----65 '0'----48
字符型直接量必须放在单引号中，只能有1个
特殊符号需要\来转义
类型间的转换：
基本数据类型从小到大依次为：byte--short--int--long--float--double
char--
两种方式：
自动/隐式类型转换：小类型到大类型
强制类型转换：大类型到小类型 语法: (要转换成为的数据类型)变量
注意：强转有可能会溢出或丢失精度
两点规则：
- 整数直接量可以直接赋值给byte,short,char，但不能超出范围
- byte,short,char型数据参与运算时，系统一律先将其转换为int再运算
命名法：
小驼峰命名法：第1个单词首字母小写，其余单词首字母大写----------变量
score,myScore,myJavaScore大驼峰命名法/帕斯卡命名法：所有单词首字母都大写--------------------类
Score,MyScore,MyJavaScore
数据类型分两种：基本数据类型、引用数据类型
内存单位换算:
1G=1024M(兆) 1M=1024KB(千字节) 1KB=1024B(字节) 1B=8bit(位)直接量：直接写出来的数(5，25，3.14，"hello"，true...)
整数直接量：直接写出来的整数(5，25)
Unicode：万国码、统一码、通用码，是世界级通用的定长(16位)字符集
4.运算符
- 算术：+、-、*、/、%、++、--
- 关系：>、<、>=、<=、==、!=
- 逻辑：&&、||、!
- 赋值：=、+=、-=、*=、/=、%=
- 字符串连接：+
- 条件/三目：boolean？数1：数2
5.分支结构
基于条件执行某语句
任何复杂的程序逻辑都可以通过三种结构来实现：
- 顺序结构：从上往下逐行执行，每句必走
- 分支结构：有条件的执行某语句，并非每句必走
- 循环结构：在特定条件下循环执行某段语句
Scanner接收用户输入的数据
分支结构：
if结构：1条路
if...else结构：2条路
if...else if结构：多条路
switch...case结构：多条路
优点：效率高、结构清晰
缺点：只能对整数判断相等
break：跳出switch
若业务是对整数判断相等，首选switch...case
循环：反复多次执行一段相同或相似的代码
循环三要素：
循环变量的初始化
循环的条件(以循环变量为基础)
循环变量的改变(向着循环的结束变)
循环变量：在整个循环过程中所反复改变的那个数
循环结构：
while结构：先判断后执行，有可能一次都不执行
do...while结构：先执行后判断，至少执行一次
当第1要素与第3要素的代码相同时，首选do...while
随机生成：
int num = (int)(Math.random()*1000+1); //1到1000之内的随机数 推导过程: Math.random()---------------0.0到0.9999999999999999... *1000-----------------------0.0到999.99999999999999... +1--------------------------1.0到1000.9999999999999... (int)-----------------------1到1000变量的作用域/范围：
从变量的声明开始，到包含它最近的大括号结束
循环结构：
- for结构：应用率最高，与次数相关的循环
三种结构如何选择：
- 先看循环是否与次数相关：
- 若相关-----------------------------直接上for
- 若无关，再看要素1与要素3的代码是否相同：
- 若相同-----------------------直接上do...while
- 若不同-----------------------直接上while
- 先看循环是否与次数相关：
break：跳出循环-------------可以用在switch和循环中
continue：跳过循环体中剩余语句而进入下一次循环-----------只能用在循环中
嵌套循环：
- 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
- 执行规则：外层循环走一次，内层循环走所有次
- 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
- break只能跳出当前层循环
6.数组
复制：
System.arraycopy(a,1,b,0,4);
int[] b = Arrays.copyOf(a,6);
a = Arrays.copyOf(a,a.length+1);
排序：
- Arrays.sort(arr); //对arr进行升序排列
7.方法：函数、过程
- 作用：封装一段特定的业务逻辑功能
- 方法应尽可能独立，一个方法只干一件事
- 方法可以被反复多次调用
- 减少代码重复，有利于代码维护
- 何时用：假设有一个功能，在很多地方都得使用，就将功能封装到一个方法中
方法的定义：五要素
修饰词 返回值类型 方法名(参数列表) {
方法体
}
方法的调用：
- 无返回值：方法名(有参传参);
- 有返回值：数据类型 变量 = 方法名(有参传参);
return：
- return 值; //1)结束方法的执行 2)返回结果给调用方-------用在有返回值的方法中
- return; //1)结束方法的执行------------------------------------用在无返回值的方法中
二、面向对象OO
1.类与对象
现实生活是由很多很多对象组成的，基于对象抽出了类
对象：软件中真实存在的单个的个体/东西
类：类型/类别，代表一类个体
类是对象的模板/模子，对象是类的具体的实例
类中可以包含：
- 对象的属性/特征/数据-----------------成员变量
- 对象的行为/动作/功能-----------------方法
一个类可以创建多个对象
如何创建类？如何创建对象？如何访问成员？
//学生类 public class Student { //成员变量 String name; int age; String address; //方法 void study(){ System.out.println(name+"在学习..."); } void sayHi(){ System.out.println("大家好，我叫"+name+"，今年"+age+"岁了，家住"+address); } } //学生类的测试类 public class StudentTest { public static void main(String[] args) { //创建一个学生对象 Student zs = new Student(); //给成员变量赋值 zs.name = "zhangsan"; zs.age = 25; zs.address = "河北廊坊"; //调用方法 zs.study(); zs.sayHi(); Student ls = new Student(); ls.name = "lisi"; ls.age = 24; ls.address = "黑龙江佳木斯"; ls.study(); ls.sayHi(); //1)创建了一个学生对象 //2)给所有成员变量赋默认值 Student ww = new Student(); ww.study(); ww.sayHi(); } }方法的签名：方法名+参数列表
方法的重载(overload/overloading)：---------------------------大大方便用户的调用
发生在同一类中，方法名相同，参数列表不同
编译器在编译时会根据方法的签名自动绑定调用方法
//方法重载的演示 public class OverloadDemo { public static void main(String[] args) { Aoo o = new Aoo(); o.show(); o.show(25); o.show("zhangsan"); o.show("zhangsan",25); o.show(25,"zhangsan"); } } class Aoo{ void show(){} void show(String name){} void show(int age){} void show(String name,int age){} void show(int age,String name){} //int show(){ return 1; } //编译错误，重载与返回值类型无关 //void show(String address){} //编译错误，重载与参数名称无关 }
概念
OO：面向对象
OOA：面向对象分析
OOD：面向对象设计
OOP：面向对象编程-------------------你们以后所参与的部分
高质量的代码：-------------想拿年薪所必须的必
- 复用性好、扩展性好、维护性好、可移植性好、健壮性好、可读性好、效率好......
类：是一种引用数据类型(是我们自己创造的一种数据类型)
// 引用 //数据类型 引用类型变量 指向 对象 Student zs = new Student();new对象时会给所有成员变量赋默认值，规则如下：
byte,short,int,long,char-------------------0 float,double-------------------------------0.0 boolean------------------------------------false 引用类型------------------------------------null
2.构造方法
构造函数、构造器、构建器---------------复用给成员变量赋初始值代码
- 作用：给成员变量赋初始值
- 与类同名，没有返回值类型(连void都没有)
- 在创建(new)对象时被自动调用
- 若自己不写构造方法，则编译器默认提供一个无参构造方法，若自己写了，则不再默认提供
- 构造方法可以重载
this：指代当前对象，哪个对象调用方法它指的就是哪个对象
只能用在方法中，方法中访问成员变量之前默认有个this.
this的用法：
this.成员变量名----------------------访问成员变量
当成员变量和局部变量同名时，若想访问成员变量，则this不能省略
this.方法名()--------------------------调用方法(可以省略，没有什么情况下是不能省略)
this()------------------------------------调用构造方法(一般不用----了解)
null：表示空，没有指向任何对象。
若引用的值为null，则该引用不能进行任何点操作了，若操作则发生NullPointerException空
指针异常。
注意
给成员变量赋初始值的代码写在构造方法中，其它业务代码还是去做普通方法
成员变量：写在类中方法外，作用范围为整个类
局部变量：写在方法中(包括方法的参数)，作用范围为当前方法
java规定：成员变量与局部变量是可以同名的，使用的时候默认采取的是就近原则
当成员变量和局部变量同名时，若想访问成员变量，则this不能省略
显示：?? related problems，表示有关联错误，不用管，找到编译错误位置改好就可以了
内存管理：由JVM来管理的------今天初体验，面向对象第10天详细讲解
- 堆：存储new出来的对象(包括成员变量)
- 栈：存储局部变量(包括方法的参数)
基本类型变量(变量)中装的是具体的数，引用类型变量(引用)中装的是对象
异常：
- ArrayIndexOutOfBoundsException：数组下标越界异常
- NullPointerException：空指针异常
引用类型数组：
- 给引用类型数组的元素赋值，需要new一下
- 若想访问对象的属性或调用方法，需要通过数组元素去打点
3.继承
作用：代码复用
通过extends来实现继承
父类：共有的属性和行为
派生类/子类：特有的属性和行为
派生类既可以访问派生类的，也能访问父类的，但父类不能访问派生类的
一个父类可以有多个派生类，一个派生类只能继承一个父类-------单一继承
具有传递性
java规定：构造派生类之前必须先构造父类
在派生类的构造方法中，若没有调用父类构造方法，则默认super()调用父类无参构造方法
在派生类的构造方法中，若自己调用了父类构造方法，则不再默认提供
注意：super()调用父类构造方法，必须位于派生类构造方法的第一行
super：指代当前对象的父类对象
super的用法：
super.成员变量名-----------------------------访问父类的成员变量
super.方法名()----------------------------------调用父类的方法
super()--------------------------------------------调用父类的构造方法
4.向上造型
------------------------------------好处：代码复用
超类型的引用指向派生类的对象
能点出来什么，看引用的类型-------------这是规定，记住就可以了
多种角色能干的事都一样的时候，可以将多种角色统一造型到超类数组中，实现代码复用
eg: 学生/老师/医生都是输出名字+问好------干的事都一样，
就可以将学生/老师/医生统一造型到Person数组中，这样一个for即可----代码复用
5.重写
- (override/overriding)：重新写
- 发生在父子类中，方法名相同，参数列表相同
- 重写方法被调用时，看对象的类型---------------------这是规定，记住就可以了
- 重写需遵循"两同两小一大"原则：------------------------ 了解，一般都是一模一样的
- 两同：
- 方法名相同
- 参数列表相同
- 两小：
- 派生类方法的返回值类型小于或等于超类方法的
- void和基本类型时，必须相等
- 引用类型时，小于或等于
- 派生类方法抛出的异常小于或等于超类方法的-----------------API时讲
- 派生类方法的返回值类型小于或等于超类方法的
- 一大：
- 派生类方法的访问权限大于或等于超类方法的-----------------明天讲
- 两同：
- 重写与重载的区别：
- 重写(override)：发生在父子类中，方法名相同，参数列表相同
- 重载(overload)：发生在同一类中，方法名相同，参数列表不同
6.package
声明包
- 作用：避免类的命名冲突
- 同包中的类不能同名，但不同包中的类可以同名
- 类的全称：包名.类名，常常有层次结构
- 建议：包名所有字母都小写
import：导入类、引入类
- 同包中的类可以直接访问，但不同包中的类不参直接访问，若想访问：
- 先import导入类再访问类-------建议
- 类的全称-----------------------------太繁琐，不建议
注意：
顺序问题：package----import----class
import 包名.*; 表示导入了包中的所有类，但不建议，建议用哪个类导哪个类
------因为.*会影响性能
7.访问控制修饰符
-----------------------------保护数据的安全
public：公开的，任何类
private：私有的，本类
protected：受保护的，本类、派生类、同包类
默认的：什么也不写，本类、同包类
注意：
java不建议默认权限
类的访问权限只能是public或默认的
类中成员的访问权限如上4种都可以
访问权限由大到小依次为：public--protected--默认的--private
- final：最终的、不可改变的--------------------单独应用几率低
- 修饰变量：变量不能被改变
- 修饰方法：方法不能被重写
- 修饰类：类不能被继承
- static：静态的
- 静态变量：
- 由static修饰
- 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 何时用：所有对象所共享的数据(图片、音频、视频等)
- 静态方法：
- 由static修饰
- 属于类，存储在方法区中，只有一份
- 常常通过类名点来访问
- 静态方法中没有隐式this传递，所以不能直接访问实例成员
- 何时用：方法的操作与对象无关
- 静态块：
- 由static修饰
- 属于类，在类被加载期间自动执行，因为一个类只被加载一次，所以静态块也只执行一次
- 何时用：加载/初始化静态资源(图片、音频、视频等)
- 静态变量：
注意
数据(成员变量)私有化(private)，行为(方法)大部分公开化(public)
成员变量分两种：实例变量和静态变量
实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份
通过引用打点来访问
静态变量：由static修饰，属于类的，存储在方法区中，只有一份
通过类名点来访问
内存管理：由JVM管理的
- 堆：new出来的对象(包括实例变量、数组的元素)
- 栈：局部变量(包括方法的参数)
- 方法区：.class字节码文件(包括静态变量、所有方法)
一般情况下：凡是静态的成员，都是公开的
8.static final常量
必须声明同时初始化
常常由类名点来访问，不能被改变
建议：常量所有字母都大写，多个单词用_分隔
编译器在编译时会将常量直接替换为具体的值，效率高
何时用：数据永远不变，并且经常使用
public class StaticFinalDemo { public static void main(String[] args) { System.out.println(Aoo.PI); //常常通过类名点来访问 //Aoo.PI = 3.1415926; //编译错误，常量不能被改变 //1)加载Boo.class到方法区中 //2)静态变量num一并存储在方法区中 //3)到方法区中获取num的值并输出 System.out.println(Boo.num); //编译器在编译时会将常量直接替换为具体的值，效率高 //相当于System.out.println(5); System.out.println(Boo.COUNT); } } class Boo{ public static int num = 5; //静态变量 public static final int COUNT = 5; //常量 } class Aoo{ public static final double PI = 3.14159; //public static final int NUM; //编译错误，常量必须声明同时初始化 }
抽象方法：
- 由abstract修饰
- 只有方法的定义，没有具体的实现(连{}都没有)
抽象类：
- 由abstract修饰
- 包含抽象方法的类必须是抽象类
- 抽象类不能被实例化
- 抽象类是需要被继承的，派生类：
- 重写抽象方法(变不完整为完整)-----------一般做法
- 也声明为抽象类-------------------------------一般不这么做
- 抽象类的意义：
- 封装共有的属性和行为--------------------代码复用
- 为所有派生类提供统一的类型-----------向上造型(代码复用)
- 可以包含抽象方法，为所有派生类提供统一的入口(造型之后能点出来)，同时可以达到强制必须重写的目的(相当于制定一个规则)
设计规则：
将共有的属性和行为，抽到超类中------------------------抽共性
若派生类的行为都一样，设计为普通方法
若派生类的行为都不一样，设计为抽象方法
抽象方法/抽象类的疑问：
- 抽象方法存在的意义是什么？
- 保证当发生向上造型时，通过超类的引用能点出来那个方法-------保证能点出方法来
- 既然抽象方法的意义是保证能点出来，那为什么不设计为普通方法呢？
- 设计为普通方法，意味着派生类可以重写也可以不重写，但设计为抽象方法，可以强制派生类必须重写--------------强制派生类重写的目的
- 抽象方法存在的意义是什么？
9.成员内部类
类中套类，外面的称为外部类，里面的称为内部类
内部类只服务于外部类，对外不具备可见性
内部类对象通常在外部类中创建
内部类中可以直接访问外部类的成员(包括私有的)，
内部类中有一个隐式的引用指向创建它的外部类对象-----外部类名.this---后面API中会用
//成员内部类的演示 public class InnerClassDemo { public static void main(String[] args) { Mama m = new Mama(); //Baby b = new Baby(); //编译错误，内部类对外不具备可见性 } } class Mama{ //外部类 private String name; void create(){ Baby b = new Baby(); //正确，内部类对象通常在外部类中创建 } class Baby{ //成员内部类 void showName(){ System.out.println(name); //简写 System.out.println(Mama.this.name); //完整写法 //System.out.println(this.name); //编译错误，当前Baby类没有name属性 } } }
10.匿名内部类
- 何时用：若想创建一个类(派生类)的对象，并且对象只被创建一次，可以设计为匿名内部类，可以大大简化代码操作
- 在匿名内部类中不能修改外面局部变量的值，因为在此处该变量会被默认为final的---API时用
- 小面试题：
- 问：内部类有独立的.class字节码文件吗？
- 答：有
//匿名内部类的演示
public class NstInnerClassDemo {
public static void main(String[] args) {
//1)创建了Aoo的一个派生类，但是没有名字
//2)为该派生类创建了一个对象，名为o1----向上造型为Aoo类型
// ---new Aoo(){}是在创建Aoo的派生类的对象
//3)大括号中的为派生类的类体
Aoo o1 = new Aoo(){
};
//1)创建了Aoo的一个派生类，但是没有名字
//2)为该派生类创建了一个对象，名为o2----向上造型为Aoo类型
// ---new Aoo(){}是在创建Aoo的派生类的对象
//3)大括号中的为派生类的类体
Aoo o2 = new Aoo(){
};
int num = 5;
num = 55;
//1)创建了Boo的一个派生类，但是没有名字
//2)为该派生类创建了一个对象，名为o3----向上造型为Boo类型
//3)大括号中的为派生类的类体
Boo o3 = new Boo(){
void show(){
System.out.println("showshow");
//num = 55; //在此处会默认外面的局部变量num为final的
}
};
o3.show();
}
}
abstract class Boo{
abstract void show();
}
abstract class Aoo{
}
- 隐式引用：
- this：指代当前对象
- super：指代当前对象的超类对象
- 外部类名.this：指代当前对象的外部类对象
- 做功能的套路：----------------------最最最最重要的一个内容
- 先写行为/功能/方法：
- 若为某个对象所特有的行为/功能，就将方法设计在特定的类中
- 若为对象所共有的行为/功能，就将方法设计在超类中
- 先写行为/功能/方法：
11.接口
是一种引用数据类型
由interface定义
只能包含常量和抽象方法
不能被实例化
接口是需要被实现/继承的，实现类/派生类：必须重写接口中的所有抽象方法
一个类可以实现多个接口，用逗号分隔。若又继承又实现时，应先继承后实现
接口可以继承接口]
注意
接口中成员的访问权限，默认就是public的，也只能是public的
接口中的数据默认都是常量，方法默认都是抽象的
关系：
- 类和类--------------------------------继承
- 接口和接口--------------------------继承
- 类和接口-----------------------------实现
设计规则：
将所有派生类所共有的属性和行为，抽到超类中------------------------抽共性
若派生类的行为都一样，设计为普通方法
若派生类的行为都不一样，设计为抽象方法
将部分派生类所共有的属性和行为，抽到接口中
接口是对继承的单根性的扩展-------------------------------实现多继承
接口是一个标准、一种规范，实现了接口就能干那个事，不实现接口就干不了那个事
12.多态
多种形态
意义：
同一个对象被造型为不同的类型时，有不同的功能------所有对象都是多态的(明天详细理解)
----对象多态：我、你、水......
同一类型的引用指向不同的对象时，有不同的实现------所有抽象方法都是多态的
----行为多态：cut()、getImage()、move()、getScore()......
向上造型/自动类型转换：
- 超类型的引用指向派生类的对象(前面是超类型，后面是派生类型)
- 能点出来什么，看引用的类型(这是规定)
- 能向上造型成为的类型有：超类+所实现的接口
强制类型转换，成功的条件只有如下两种：
- 引用所指向的对象，就是该类型
- 引用所指向的对象，实现了该接口或继承了该类
强转若不符合如上条件，则发生ClassCastException类型转换异常
建议：在强转之前一定要先通过instanceof来判断引用的对象是否是该类型
强转时若符合如上的两个条件，则instanceof返回true，若不符合则返回false
何时需要强转：你想访问的东西在超类中没有，那就需要强转
public class MultiType { public static void main(String[] args) { //条件1:引用所指向的对象，就是该类型 //条件2:引用所指向的对象，实现了该接口或继承了该类 Aoo o = new Boo(); //向上造型 Boo o1 = (Boo)o; //引用o所指向的对象，就是Boo类型-------符合条件1 Inter o2 = (Inter)o; //引用o所指向的对象，实现了Inter接口---符合条件2 //Coo o3 = (Coo)o; //运行时会发生ClassCastException类型转换异常 //判断o是否是Coo类型(与强转成功条件完全匹配) if(o instanceof Coo){ //false Coo o4 = (Coo)o; //instanceof若为true，则强转一定成功 }else{ System.out.println("o不是Coo类型"); } } } interface Inter{ } class Aoo{ } class Boo extends Aoo implements Inter{ } class Coo extends Aoo{ }
13.内存管理
由JVM来管理的----------我笔记里面有哪些就先记哪些
堆：
存储的是new出来的对象(包括实例变量、数组的元素)
垃圾：没有任何引用所指向的对象
垃圾回收器(GC)不定时到堆中清扫垃圾，回收过程是透明的(看不到的)，并不一定一发现垃圾就立刻回收，通过调用System.gc()建议虚拟机尽快调度GC来回收
实例变量的生命周期：
在创建时对象时存储在堆中，对象被回收时一并被回收
内存泄漏：不再使用的对象还没有被及时的回收，严重的泄漏会导致系统的崩溃
建议：不再使用的对象应及时将引用设置为null
栈：
存储正在调用的方法中的局部变量(包括方法的参数)
调用方法时会在栈中为该方法分配一块对应的栈帧，栈帧中存储局部变量(包括方法的参数)，方法调用结束时，栈帧被自动清除，局部变量一并被清除
局部变量的生命周期：
调用方法时存储在栈中，方法调用结束时与栈帧一并被清除
方法区：
- 存储.class字节码文件(包括静态变量、所有方法)
- 方法只有一份，通过this来区分具体的调用对象
面向对象三大特征总结：-------------非常重要，一定要记住
封装：
- 类：封装的是对象的属性和行为
- 方法：封装的是具体的业务逻辑功能实现
- 访问控制修饰符：封装的是具体的访问权限
继承：
作用：代码复用
超类：所有派生类所共有的属性和行为
接口：部分派生类所共有的属性和行为
派生类：派生类所特有的属性和行为
单一继承、多接口实现，具有传递性
多态：
所有对象都是多态的----------------通过向上造型来体现的
所有抽象方法都是多态的----------通过方法的重写来体现的
向上造型、强制类型转换、instanceof判断
String：字符串类型
java.lang.String使用final修饰，不能被继承
String的底层封装的是一个字符数组
String在内存中采用Unicode编码格式，每个字符占用两个字节的空间
字符串一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值(指向新的对象)
--------不变对象
字符串常量池：
java对String字符串有一个优化措施：字符串常量池(堆中)
java推荐我们使用字面量/直接量的方式来创建对象，并且会缓存所有以字面量形式创建的字符串对象到常量池中，当使用相同字面量再创建对象时将会复用常量池中的对象，以减少内存开销。
注意：只有使用字面量方式创建的对象，才会存储在字符串常量池中