java
下载java： oracle.com
下载IDE： jetbrains.com
cmd命令可通过help列表查找
JVM(java virtual machine) :java虚拟机
JRE(java runtime environment) :java运行环境 包含JVM
JDK(java development kit) :java开发工具 包含JRE
下载java安装包
oracle.com 选择java SE 9 下载
安装java安装包时
路径尽量不要有汉字、空格 防止乱码
JDK中已包含JRE，故不需要选择外部JRE
修改环境变量(方便使用，以后可以不用输入冗长的路径名)
此电脑->属性->高级系统设置->高级->环境变量->系统环境变量
新建 变量名：JAVA_HOME
变量值：安装路径(如D:\Java\jdk-9.0.4)
修改PATH： 新增%JAVA_HOME%\bin;
常量： 字符串常量、整数常量、浮点数常量、字符常量、布尔常量、空常量
基本数据类型：
整数型
字节型 byte : 1字节 -128~127
短整型 short ： 2字节 -32768~32767 (大概在正负三万多之间)
整形 int ： 4字节 -231~ 231-1 (大概在正负21亿之间)
长整型 long : 8字节 -263~263-1
浮点型
单精度型 float : 4字节 1.4013E-45~3.4028E+38
双精度型 double : 8字节 4.9E-324~1.7977E+308
字符型 char : 2字节 0~65535
布尔型 boolean : 1字节 true, false
引用数据类型
字符串
数组
类
接口
Lambda
基本类型注意事项：
- 字符串不是基本类型，而是引用类型
- 浮点型可能只是一个近似值，并非精确的值
- 数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节
- 浮点数当中默认类型是double，如果一定要使用float类型，需要加上后缀F。
如果是整数，默认为int类型，如果一定要使用long类型，需要加上一个后缀L。 后缀不区分大小写，推荐使用大写
使用基本类型注意事项：
- 如果创建多个变量，变量名不能重复
- 使用float和long类型的数据，不要丢到后缀F和L (如：1.3F 、 3000000000L)
- 使用byte和short类型的数据，注意数据的范围 ( byte ：-128~127， short: -32768~32767)
- 未赋值的变量，使用会报错
- 变量使用不能超过作用域的范围
【作用域】：从定义变量的一行开始，一直到直接所属的大括号结束为止 - 可通过一个语句来创建多个变量(不推荐)
数据类型转换: 当数据类型不一样时，会发生数据类型转换
自动类型转换（隐式）
1. 特点：代码不需要特殊处理，自动完成
2. 规则：数据范围从小到大
/*
示例
public class Demo01DataType {
public static void main(String args[]) {
short num1 = 1; //从int强转成了short,因为是常量,能够确定数据大小,不会造成数据丢失
System.out.println(num1+1); //可以直接计算，最终的结果是int类型
//num1 = num1 + 1; //报错，右边计算后是int类型，可能造成数据丢失
System.out.println(num1);
//int num2 = 2L; //上面的错误原因与此类似
//System.out.println(num2);
float num3 = 10;
System.out.println(num3); //显示结果为10.0
}
}
*/
强制类型转换（显式）
1. 特点：代码需要特殊的格式处理，不能自动完成
2. 格式：范围小的类型 范围小的变量名 = （范围小的类型） 原本范围大的数据
如： int num = (int) 100L;
注意事项：
1. 注意数据溢出、精度损失
2. byte/short/char 在运算时会全部自动转成int，然后再进行计算
3. boolean不能进行数据转换
/*
示例：
public class Demo02Datatype {
public static void main(String args[]) {
int num = (int) 100L;
System.out.println(num);
//long --> int 数据溢出
//强转格式： 类型 变量名 = （类型）数据
int num2 = (int) 6000000000L;
System.out.println(num2);
//float --> int 精度损失
int num3 = (int) 3.5;
System.out.println(num3);//3，直接舍弃小数
//byte/char/short 一旦进行运算，将自动转成int类型,然后再进行运算
char zifu1 = 'A';
System.out.println(zifu1 + 1);//66
byte num4 = 40, num5 = 50, num6;
//byte + byte --> int + int --> int
//num6 = num4 + num5;//报错
int num7 = num4 + num5;
System.out.println(num7);
}
}
*/
ASCII码表
48 — 0
97 — a
65 — A
循环
三种循环： for while do…while
for (初始化; 判断条件; 步进运算) {
循环体;
}
while (判断条件) {
循环体;
步进运算;
}
do {
循环体;
步进运算;
}while(判断条件);
判断的结果只能为 boolean 类型的变量，不能如C一样写while(1)而是while(true)
循环控制语句：
break ：直接跳出当前循环，剩余次数不再执行，多重循环只跳一层
continue ：跳过当前一次循环，从下一次开始继续执行
ItelliJ IDEA快捷键
ctrl+Y ：删除当前行
ctrl+D ：复制当前行
shift+上下 ：多选行
shift+alt+上下 ：上下移动
crtl+alt+L ：自动对齐
crtl+shift+/ ：多行注释
ctrl+/ ：单行注释
alt+Ins ：自动生成set等方法代码
alt+Enter ：自动导入包
方法重载（OverLoad）:
方法的名称一样，参数列表不一样(实现了一个方法多个功能)
方法重载与下列因素相关：
1. 参数个数不同
2. 参数类型不同
3. 参数的多类型顺序不同
方法重载与下列因素无关：
- 参数的名称
- 与方法的返回值类型无关
数组
数组初始化分为两种：
动态初始化（指定长度）
动态初始化数组的格式：
数据类型[] 数组名称 = new 数据类型[数组长度];
静态初始化（指定内容）
静态初始化数组的格式：
//标准格式：
数据类型[] 数组名称 = new 数据类型[] {元素1, 元素2, …};
//省略格式：
数据类型[] 数组名称 = {元素1,元素2, …};
注意事项：
- 静态初始化虽然没有指定数组长度，但是可以自动推算出长度
- 静态初始化的标准格式可以拆分成两个步骤（省略格式不能），先定义后开辟空间。（动态初始化也能拆分成两个步骤）
3. 动态初始化数组时，每个元素会有一个默认值
整数 -> 0
浮点数 -> 0.0
字符型 -> ‘\u0000’
布尔型 -> false
引用型 -> null
两种编程思想
面向过程：当需要实现一个功能的时候，每一个步骤都需要亲力亲为，详细处理每一个细节
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经有该功能的人，来帮我做事
面向对象的特点：具有封装性、继承性和多态性
类：一组相关属性和行为的集合
成员变量（属性）：状态信息
成员方法（行为）：能够做什么
注意事项：
-
成员变量是直接定义在类当中，方法的外面
-
成员方法不要写static关键字
-
通常情况下，一个类不能直接使用，需要创建一个对象才能使用
-
导包
指出需要使用的类在什么位置
import 包名称.类名称；
对于和当前类属于同一个包的情况，可以省略导包语句不写
-
创建
类名称 对象名 = new 类名称();
-
使用
使用成员变量： 对象名.成员变量名
使用成员方法： 对象名.成员方法名(参数)
-
-
如果成员变量没有进行赋值，会有一个默认的初始值，规则和数组一样
（未初始化的变量，直接使用会报错，此处虽未赋值，但在new的过程中已初始化）
局部变量和成员变量：
-
定义的位置不一样
局部变量：在方法的内部
成员变量：在方法的外部，直接写在类当中
-
作用范围不一样
局部变量：只有在方法当中才可以使用
成员变量：整个类全部可以通用
-
默认值不一样
局部变量：没有默认值，必须手动赋值
成员变量：如果没有赋值，会有默认值，规则同数组一样
-
内存位置不一样
局部变量：位于栈区
成员变量：位于堆区
-
生命周期不一样
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
封装性在java中的体现：
-
方法就是一种封装
-
关键字private也是一种封装
一旦使用了private进行修饰，本类当中可以随意访问，但超出本类范围将不能直接进行访问
间接访问private成员变量，就是定义一对Getter/Setter方法
必须叫getXxx或者是setXxx命名规则
对于Getter，不能有参数，返回值类型和成员变量类型对应
对于Setter，不能有返回值，参数类型与成员变量类型对应
对于基本类型boolean，Getter方法一定要也称isXxx，Setter方法不变
继承性：
继承是多态的前提，没有继承就没有多态
继承主要解决的问题：共性抽取
分为父类（或称基类）和子类（又称派生类）
继承关系当中的特点：
- 子类可以拥有父类的“内容”
- 子类还可以拥有自己专有的内容
在继承关系中，“子类就是一个父类”。也就是说，子类可以被当作父类看待
例如父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a
定义父类的格式：（一个普通的类定义）
public class 父类名称 {
//…
}
定义子类的格式：
public class 子类名称 extends 父类名称 {
//…
}
Java语言是单继承的
一个类的直接父类只能有唯一一个
一个类可以多级继承
一个父类可以有多个子类
抽象方法
如果父类当中的方法不确定如何进行{}方法体实现，那么这就应该是一个抽象方法
抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可
如：
//抽象类
public abstract Animal {
//抽象方法
public abstract void eat();
//普通方法
public void normalMethod() {
//方法体
}
}
如何使用抽象类和抽象方法：
-
用一个子类来继承抽象父类
-
子类覆盖重写抽象父类当中所有的抽象方法
覆盖重写（实现）：去掉抽象方法的abstract关键字，然后补上方法体和大括号
-
创建子类对象进行使用
注意事项：
-
抽象类不能创建对象（创建则编译报错）
-
抽象类中可以有构造方法，用于提供子类创建对象时初始化抽象类成员变量
-
抽象类中不一定包含抽象方法，但抽象方法必须在抽象类中
不包含抽象类的目的：不想让调用者创建该类对象，通常用于某些特殊的类结构设计
-
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则编译报错(除非该子类也是抽象类)
-
抽象类可多级继承，但在覆盖重写完所有方法之前的类都算抽象类，如下：
/*最顶层抽象类*/
public abstract class TestAbstract {
public abstract void eat();
public abstract void sleep();
}
/*继承后重写了一个抽象方法，未能全部覆盖重写，依旧算抽象类*/
public abstract class HaDog extends TestAbstract {
@Override
public void eat() {
System.out.println("爱吃鱼");
}
}
/*抽象方法全部覆盖重写完毕，作为普通类*/
public class Ha2 extends HaDog {
@Override
public void sleep() {
System.out.println("呼呼呼");
}
}
/*在使用时，只能对普通类实例化，不能创建抽象类的对象*/
public class Demo {
public static void main(String[] args) {
Ha2 ha = new Ha2();
ha.eat();
ha.sleep();
}
}
父类、子类变量重名情况：
在父子类的继承关系当中，如果成员变量重名，则创建子类对象是，访问方式有两种：
Zi obj = new Zi();
-
直接通过子类对象访问成员变量：
看等号的左边是谁，就优先用谁，没有则向上找(因为变量不会覆盖重写)
-
间接通过成员方法访问成员变量：
该方法属于谁（谁定义的），就优先用谁，没有则向上找
父类、子类、局部变量重名解决办法:
局部变量： 直接写变量名
本类的成员变量： this.成员变量名
父类的成员变量： super.成员变量名
父类、子类方法重名情况：
在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
Zi obj = new Zi();
等号的右边是谁，就优先用谁，没有则向上找(因为方法会进行覆盖重写)
注意事项：
无论是成员变量还是成员方法，如果没有都是向上找父类，绝对不会向下找子类的
重写（Override）
一种重要的设计思想：在版本更新换代过程中，新版本要兼容老版本，就让新版本继承老版本，同时对要更新的方法进行覆盖重写，从而达到向下兼容的效果
概念：在继承关系当中，方法的名称一样，参数列表也一样
重写（Override）：方法的名称一样，参数列表也一样。 覆盖、覆写
重载（Overload）：方法的名称一样，参数列表不一样。
方法的覆盖重写特点：
创建的是子类对象，则优先用子类方法
方法覆盖重写的注意事项：
-
必须保证父子类之间的方法名称相同、参数列表也相同
@Override：可通过在方法的上面写上此注解，来自动检测是不是有效的覆盖重写
-
子类方法的返回值必须小于等于父类方法的返回值范围
-
子类方法的权限必须大于等于父类方法的权限修饰符
public > protected > (default) > private (default不是关键字，代表什么都不写)
继承关系中，父子类构造方法的访问特点：（super()）
-
子类构造方法中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造
public class TestSon extends TestFather{ public TestSon() { super(); //没写时系统默认会生成一个， 而且只能写在最开始处，否则报错 System.out.println("子类构造执行"); } public void method() { // super(); //错误写法！只有子类构造方法，才能调用父类构造方法，且只能一次 } } -
可以通过super关键字在子类构造方法中调用父类的重载构造方法（即可以通过super调用父类的有参构造）
-
若不要默认，要自己写super()调用父类的构造，必须是子类构造的第一个语句，不能一个子类构造调用多次super构造
总结：
子类构造必须调用父类构造，不写则默认有一个super();写了则用指定的super调用。super只能有一个，且必须是子类构造的第一个语句。
super关键字的三种用法：
- 在子类的成员方法中，访问父类的成员变量（如super.num）
- 在子类的成员方法中，访问父类的成员方法（如super.method()）
- 在子类的构造方法中，访问父类的构造方法（如super()）
this指针
this.name这种写法能够避免重名的情况
通过谁调用的方法，谁就是this
super关键字用来访问父类内容，而this关键字用来访问本类内容
this关键字的三种用法：
-
在本类的成员方法中，访问本类的成员变量（如this.num）
-
在本类的成员方法中，访问本类的另一个成员方法（如this.method2()）
-
在本类的构造方法中，访问本类的另一个构造方法（如this.Test(1)）
在使用第三种是要注意：
A. this(…)调用也必须是构造方法的第一个语句，且为当前代码块中的唯一一个
B. super和this两个进行构造方法调用时，不能同时使用
接口
接口就是多个类的共同规范
接口是一种引用数据类型，最重要的内容就是其中的：抽象方法
定义一个接口的格式：
public interface 接口名称 {
//接口内容
}
备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java -> .class
接口可包含的内容：
如果是Java 7，接口可包含：
- 常量
- 抽象方法
如果是Java 8，还可额外包含：
- 默认方法
- 静态方法
如果是Java 9，还可额外包含：
- 私有方法
接口定义抽象方法
格式如下：
pubilc abstract 返回值类型 方法名称(参数列表);
注意事项：
- 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
- 这两个关键字可以选择性的省略（可以全部省略，也可以部分省略）
接口使用步骤：
-
接口不能直接使用，必须有一个“实现类”来“实现”该接口
格式如下：
public class 实现类名称 implements 接口名称 { // ... } -
接口的实现类必须覆盖重写(实现)接口中所有的抽象方法
实现：去掉abstract关键字，加上方法体大括号
-
创建实现类的对象，进行使用
注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类就是抽象类
接口定义默认方法
格式如下：
public default 返回值类型 方法名称(参数列表) {
//方法体
}
备注：接口当中的默认方法，可以解决接口升级的问题
/*定义一个接口*/
public interface MyInterfaceDefault {
//定义了一个抽象方法
public abstract void MyInterfaceAbsA();
//定义了一个默认方法，直接在此处就将实现写好
public default void MyInterfaceDefault() {
System.out.println("实现了一个默认方法");
}
}
/*定义了一个实现类*/
public class MyInterfaceAbstractImp implements MyInterfaceDefault {
//实现抽象方法
@Override
public void MyInterfaceAbsA() {
System.out.println("实现了一个抽象方法");
}
}
/*定义了另一个实现类*/
public class MyInterfaceAbstractImpl02 implements MyInterfaceDefault{
//抽象方法的另一种实现
@Override
public void MyInterfaceAbsA() {
System.out.println("实现了另一种抽象方法");
}
}
public class Demo {
public static void main(String[] args) {
MyInterfaceAbstractImp myInterface = new MyInterfaceAbstractImp();
myInterface.MyInterfaceAbsA();
MyInterfaceAbstractImpl02 myInterface02 = new MyInterfaceAbstractImpl02();
myInterface02.MyInterfaceAbsA();
/*
调用默认方法，如果实现类中没有，会向上到接口中找
*/
myInterface.MyInterfaceDefault();
myInterface02.MyInterfaceDefault();
}
}
注意事项：
- 接口的默认方法，可以通过接口 实现类对象直接调用
- 接口的默认方法，也可以被接口 实现类 覆盖重写
接口定义静态方法
格式如下：
public static 返回值类型 方法名称(参数列表) {
//方法体
}
注意事项：
不能通过接口实现类的对象来调用接口当中的静态方法，要调用静态方法时，直接通过接口名调用
格式为： 接口名称.静态方法名(参数)；
接口定义私有方法
-
普通私有方法：解决多个默认方法之间重复代码问题
格式如下：
private 返回值类型 方法名称(参数列表) { //方法体 } -
静态私有方法：解决多个静态方法之间重复代码问题
格式如下：
private static 返回值类型 方法名称(参数列表) { //方法体 }
public interface MyInterfacePrivate {
public abstract void doNothing();
public default void myDefault() {
System.out.println("我的默认方法");
myPrintStatic(); //默认方法可以调用普通私有方法，同时也能调用静态私有方法
}
public static void myStatic() {
System.out.println("我的静态方法");
myPrintStatic(); //静态方法可以调用静态私有方法，但是不能调用普通私有方法
}
/* private void myPrintDefault() {
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}*/
/*静态私有方法*/
private static void myPrintStatic() {
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
}
注意事项：
- 默认方法不管是私有的普通方法还是静态方法都能调用，私有方法只能调私有静态方法
接口定义常量
接口当中也可以定义“成员变量”即常量，必须用public static final三个关键字修饰，格式如下：
public static final 数据类型 常量名称 = 数据值; //一旦赋值，不可修改
备注：
一旦使用final关键字进行修饰，说明不可改变
注意事项：
- 接口当中的常量，可以省略public static final，不写默认也是这样
- 接口当中的常量，必须进行赋值，否则报错
- 接口中的常量名称，全部使用大写字母，多个单词用下划线分隔
总结：
-
成员变量其实是常量，格式：
[public] [static] [final] 数据类型 常量名称 = 数据值;注意：
常量必须进行赋值，而且一旦赋值不能改变
常量名称完全大写，用下划线分割
-
接口中最重要的就是抽象方法，格式：
[public] [abstract] 返回值类型 方法名称(参数列表);注意：实现类必须覆盖重写所有的抽象方法，除非实现类也是抽象类
-
从Java 8开始，接口里允许定义默认方法，格式：
[public] default 返回值类型 方法名称(参数列表) {方法体}注意：默认方法也可以被覆盖重写
-
从Java 8开始，接口里允许定义静态方法，格式：
[public] static 返回值类型 方法名称(参数列表) {方法体}注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法
-
从Java 9开始，接口里允许定义私有方法，格式：
//普通私有方法 [private] 返回值类型 方法名称(参数列表) {方法体} //静态私有方法 [private] [static] 返回值类型 方法名称(参数列表) {方法体}注意：private的方法只有接口自己才能调用，不能被实现类或别人使用
使用接口注意事项
-
接口是没有静态代码块和构造方法的
-
一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
格式如下:
public class MyInterfaceImpl implemenets MyInterfaceA, MyInterfaceB { //覆盖重写所有方法 } -
如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次即可
-
如果实现类没有覆盖重写所有接口当中的所有方法，那么这个实现类必须是一个抽象类
-
如果实现类所实现的多个接口中，存在重复的默认方法，那么必须覆盖重写冲突的默认方法
-
一个类如果直接父类中的方法，和接口中的默认方法产生了冲突，优先用父类当中的方法
类与接口之间的关系
-
类与类之间是单继承的，直接父类只有一个
-
类与接口之间是多实现的，一个类可以实现多个接口，如下：
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB { //方法体 } -
接口与接口之间是多继承的，如下：
public interface MyInterfaceImpl extends MyInterfaceA, MyInterfaceB { //方法体 }注意事项：
- 多个父类接口中的抽象方法如果重复，没关系
- 多个父类接口中的默认方法如果重复，那么子接口必须重写默认方法，且关键字default不可省略
多态性（polymorphism）
父类引用指向子类对象，右侧子类对象被当成父类使用（如：一只猫被当成动物）
//格式如下
父类名称 对象名 = new 子类名称();
//或者
接口名称 对象名 = new 实现类名称();
访问成员变量的两种方式：
- 直接通过变量名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找
- 间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找
成员方法访问规则：
看new的是谁，优先用谁，没有则向上找
口诀：编译看左边，运行看右边（此口诀对成员变量无效）
示例如下：
/*父类*/
public class Fu {
public int num = 10;
public void show() {
System.out.println(num);
}
public void method() {
System.out.println("这是父类方法");
}
public void methodFu() {
System.out.println("这是父类独有的方法");
}
}
/*子类*/
public class Zi extends Fu {
public int num = 20;
public void method() {
System.out.println("这是子类方法");
}
}
/*创建对象调用*/
public class TestMultiField {
public static void main(String[] args) {
Fu obj = new Zi();
//直接访问成员方法，等号的右边是谁，就调谁
obj.method(); //显示的为子类方法，因为方法被子类方法覆盖了
obj.methodFu(); //显示的为父类方法，因为子类中没有进行覆盖重写
//直接访问成员变量，等号的左边是谁，就调谁
System.out.println(obj.num); //显示的是父类中的10，因为变量不能覆盖
//间接通过成员方法访问成员变量，谁定义的方法，就调谁的
obj.show();
}
}
多态写法的好处：
通过给父类引用不同的子类，实现了父类对不同子类方法的调用，提升了代码的灵活性
向上转型与向下转型：
对象的向上转型
其实就是***多态***的写法，格式如下：
父类名称 对象名 = new 子类名称();
含义：右侧创建了一个子类对象，把他当作父类来看待使用
Animal animal = new Cat(); //创建了一只猫，当作动物看待，没问题
注意事项：向上转型一定是安全的，类似于：double num = 100;
对象的向下转型
其实就是一个***还原***的动作，格式如下：
子类名称 子类对象 = (子类名称)父类对象;
含义：将父类对象，***还原***成了本来的子类对象
Animal animal = new Cat(); //本来是猫，向上转型成动物
Cat cat = (Cat)animal; //本来是猫，已经被当成动物了，还原为原来的猫
注意事项: 必须保证***还原的类型***与对象***原本创建(new)的***类型一致，否则运行报错(编译不报错)ClassCastException
判断一个父类引用的对象是何类型的方法
格式如下：
对象 instanceof 类名称
这将会得到一个boolean值结果，作用是判断前面的对象是不是后面的类的实例
示例如下：
//动物类
public abstract class Animal {
public abstract void eat();
}
//猫类
public class Cat extends Animal {
public void eat() {
System.out.println("猫吃鱼");
}
public void call() {
System.out.println("喵喵喵");
}
}
//狗类
public class Dog extends Animal {
public void eat() {
System.out.println("狗啃骨头");
}
public void watchHouse() {
System.out.println("狗看家");
}
}
//创建对象，演示多态、向上向下转型、判断类型
public class Demo {
public static void main(String[] args) {
Animal animal = new Dog(); //向上转型，同时也是多态的体现
animal.eat();
if (animal instanceof Cat) { //判断类型
Cat cat = (Cat) animal; //向下转型
cat.call();
}
if (animal instanceof Dog) {
Dog dog = (Dog) animal; //向下转型
dog.watchHouse();
}
}
}
个人想法（向上向下转型）：用于访问权限
多级继承，逐层写入不同方法，越往下走方法越多，访问权限越大
例如连续继承了3次，
Class0 //权限最低
Class1 extends Class0
Class2 extends Class1 //权限最高
初始时，通过向上转型，Class0类引用Class2
此时，虽然具有Class2类的数据，但是只能使用Class0所拥有的部分，权限最低
需要提升权限时，根据情况向下转型为Class1或Class2类
继承、接口、多态的小结
继承的内容
//父类
public class xxx{}
//子类
public class *** extends xxx {}
抽象方法与抽象类
抽象方法：只有声明，子类中去覆盖重写
抽象类：不能创建对象、可有构造方法
/*抽象类*/
public abstract class xxx {
public abstract void method(); //抽象方法声明
}
/*继承抽象类，子类中覆盖重写*/
public class *** extends xxx { //继承
//覆盖重写
public void method() {
//...
}
}
子类、父类重名情况：
- 不管是变量还是方法，遵循谁调用谁优先，没有再向上找
- 局部变量直接用，本类this，父类super
覆盖重写
覆盖重写：方法名称一样，参数列表一样
重载：方法名称一样，参数列表不一样
覆盖重写遵循：
- 一般前面写@Override进行重写检测
- 子类方法的返回值小于等于父类方法的返回值范围
- 子类方法的权限大于等于父类方法的权限修饰符
继承默认调用父类构造方法情况：
子类构造方法（不管自己写还是默认生成的），都会默认生成一个super()来调用父类的构造方法，自己写则必须写在构造方法的第一行，且只能写一个
接口的内容
//接口
public interface xxx {}
接口及方法的定义
public interface xxx {
//接口定义常量
//必须赋值，常量名大写，用下划线分隔
[public] [static] [final] int NUM_OF_CONST = 10;
//接口声明抽象方法
//实现类中必须覆盖重写此方法
[public] [abstract] void methodAbs();
//接口定义默认方法
//实现类中可以直接使用，创建的对象也可直接使用
[public] default void methodDefault() {
//方法体
}
//接口定义静态方法
//可以通过接口名.方法名称直接使用
[public] static void methodStatic() {
//方法体
}
//接口定义普通私有方法
//本接口中才能使用(本接口的静态方法也不能用)，且其他地方都不能用，起到保护和隐藏作用
[private] void methodPrivateNormal() {
//方法体
}
//接口定义静态私有方法
//只有本接口中才能用(本接口的方法都能用)
[private] [static] void methodPrivateStatic() {
//方法体
}
}
接口的实现类
public class *** implements xxx {
//实现类中必须覆盖重写所有的抽象方法，除非此类依旧是抽象类
public void method() {
//方法体
}
}
注意：
- 接口没有静态代码块和构造方法（继承可以有）
- 一个类可以同时实现多个接口(一个类只能继承唯一一个父类)
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {}
public class MyExtend extends MyFatherClass {} - 重复情况：
A: 实现类同时实现多个接口，但是有抽象方法冲突，直接覆盖重写一次即可
B: 接口中有抽象方法，实现类若没覆盖重写完，则是一个抽象类
C: 实现类同时实现多个接口，但是有默认方法冲突，直接覆盖重写冲突的默认方法即可
D: 若有一个类，同时继承父类，同时实现接口，父类的方法名与接口的默认方法冲突，优先使用父类方法
类与接口的关系
- 类与类之间是单继承的，子类只能有一个父类
- 类与接口之间是多实现的，实现类可以同时实现多个接口
- 接口与接口之间是多继承的，接口可以同时继承多个接口
注意：- 多个父类接口中的抽象方法重复可以不管（因为抽象方法都得在子类中覆盖重写）
- 多个父类接口中的默认方法如果重复，子接口必须覆盖重写默认方法，且不能省略default关键字
多态的内容
父类引用子类的对象，子类被当成父类使用，增加灵活性
//继承的方式：
父类名称 对象名 = new 子类名称();
//接口的方式：
接口名称 对象名 = new 实现类名称();
访问成员变量规则：
直接通过对象名访问：看等号的左边是谁，就优先用谁，没有则向上找
间接通过成员方法访问：方法是谁定义的，就优先用谁，没有则向上找
访问成员方法的规则：
看等号的右边是谁，就优先用谁，没有则向上找(即：谁new的就用谁)
备注：此处说的等号是创建对象时的等号，即 Fu fu = new Zi(); 这个时候的等号
向上转型与向下转型
向上转型：
父类名称 对象名 = new 子类名称(); //其实就是多态的写法向上转型一定安全，因为父类的范围更大
向下转型：
子类名称 对象名 = (子类名称)父类对象 //其实就是将向上转型的对象还原回来
向下转型一定要还原为原类型，否则会报错(运行时报错)
向下转型前判断类型方法：
对象 instanceOf 类名称 //返回值为一个boolean类型，若对象是后面的类型则返回true
构造方法
构造方法是专门用来创建对象的方法，通过关键字new来创建对象时，其实就是在调用构造方法
格式：
public 类名称(参数类型 参数名称) {
方法体;
}
注意事项：
-
构造方法的名称必须和所在类的名称完全一样，大小写保持一致
-
构造方法不需要返回值类型，void也不能写
-
构造方法不能return一个具体的返回值
-
如果没有编写任何构造方法，那么编译器会默认生成一个构造方法，其中没有参数、方法体什么事情都不做
形如public Student() {}
-
一旦编写了至少一个构造方法，那么编译器将不会自动生成构造方法
-
构造方法可以重载
一个标准的类通常具有以下4个组成部分：
-
所有的成员变量都用private关键字修饰
-
为每一个成员变量编写一个Setter/Getter方法
-
编写一个无参的构造方法
-
编写一个全参的构造方法
这样标准的类也称Java Bean
API
API（application program interface）应用程序编程接口，是JDK提供给我们直接使用的类
引用类型的一般使用步骤：
-
导包
import 包路径.类名称；
目标类和当前类在同一个包，则可以省略导包语句
只有java.lang包下的内容不要导包，其他的包都需要import语句
-
创建
类名称 对象名 = new 类名称();
-
使用
对象名.成员方法();
常用API：Scanner
导包：import java.util.Scanner
创建：Scanner sc = new Scanner(System.in);//System.in代表从键盘进行输入
使用：
获取键盘输入的一个int数字：int num = sc.nextInt();
获取键盘输入的要给字符串：String str = sc.next();
常用API：Random
Random类：用于生成随机数
导包：import java.util.Random
创建：Random r = new Random();
使用：
获取一个随机的int数字(范围是int所有范围，有正负两种（-21个亿~+21个亿）)：int num = r.nextInt();
获取一个随机的int数字(参数代表了范围，左闭右开区间): int num = r.nextInt(10) //[0,10)区间的随机数
常用API：ArrayList
数组的长度不可以发生改变，但ArrayList集合的长度是可以随意改变的
导包：import java.util.ArrayList
创建：ArrayList<类型> list = new ArrayList<>();
对于ArrayList来说，有一个尖括号代表泛型
泛型：也就是装在集合当中的所有元素，全都是统一的类型（注意：泛型只能是引用类型，不能是基本类型）
使用：
list.add(参数);//向集合中添加元素
注意事项：
-
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。如果内容为空，得到的是空的中括号：[]
-
如果希望向ArrayLIst集合中存储基本数据类型，必须使用基本类型对应的“包装类”
基本类型 包装类（引用类型，包装类都位于java.lang包下）
byte Byte
short Short
int Integer 特殊
long Long
float Float
double Double
char Character 特殊
boolean Boolean
从JDK 1.5+开始，支持自动装箱、自动拆箱
自动装箱：基本类型–>引用类型
自动拆箱：引用类型–>基本类型
ArrayList当中常用的方法有：
public boolean add(E e):向集合中添加元素，参数的类型和泛型一致
public E get(int index):向集合中获取元素，参数是索引编号，返回值就是对应位置的元素
public E remove(int index):从集合中删除元素
public int size():获取集合的尺寸长度，返回值就是集合中元素的个数
ArrayLIst练习
数值添加到集合
生成6个1~33之间的随机整数，添加到集合，并遍历集合
import java.util.ArrayList;
import java.util.Random;
public class TestArrayRandom {
public static void main(String[] args) {
//创建ArrayList对象
ArrayList<Integer> list = new ArrayList<>();
//生成6个随机数并添加到对象中
for (int i = 0; i < 6; i++) {
list.add((new Random().nextInt(32)) + 1);
}
System.out.println(list);
//遍历集合
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
对象添加到集合
自定义4个学生对象，添加到集合，并遍历
import java.util.ArrayList;
class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class TestArrayListPerson {
public static void main(String[] args) {
//创建集合对象
ArrayList<Student> list = new ArrayList<>();
//创建学生对象
Student stu1 = new Student("Tom", 18);
Student stu2 = new Student("Jack", 29);
Student stu3 = new Student("Marry", 18);
Student stu4 = new Student("Mei", 25);
//添加元素到集合
list.add(stu1);
list.add(stu2);
list.add(stu3);
list.add(stu4);
//遍历集合
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).getName() + "----" + list.get(i).getAge());
}
}
}
打印集合方法
定义以指定格式打印集合的方法(ArrayList类型作为参数)，使用{}括起集合，使用@分隔每个元素。格式参照{元素@元素@元素}
import java.util.ArrayList;
public class TestArrayListPrint {
public static void main(String[] args) {
//创建集合对象
ArrayList<String> list = new ArrayList<>();
//添加元素到集合中
list.add("张三");
list.add("李四");
list.add("王麻子");
list.add("黑瞎子");
//调用方法
testArrayListPrint(list);
}
public static void testArrayListPrint(ArrayList<String> list) {
//左括号
System.out.print("{");
//遍历集合
for (int i = 0; i < list.size(); i++) {
if (i < list.size() - 1) {
//打印+@
System.out.print(list.get(i) + "@");
} else {
//最后一个元素打印时加上右括号
System.out.println(list.get(i) + "}");
}
}
}
}
集合筛选：
用一个大集合存入20个随机数字，然后赛选其中的偶数元素，放入到小集合中(要i去使用自定义的方法来实现筛选)
import java.util.ArrayList;
import java.util.Random;
public class SelectEven {
public static void main(String[] args) {
//创建大集合对象
ArrayList<Integer> listHuge = new ArrayList<>();
//向集合中添加20个随机元素
for (int i = 0; i < 20; i++) {
listHuge.add(new Random().nextInt(100));
}
//显示大集合数据
System.out.println(listHuge);
//创建小集合，并调用方法接收筛选后的偶数小集合
ArrayList<Integer> listSmall = selectEven(listHuge);
//显示小集合数据
System.out.println(listSmall);
}
public static ArrayList<Integer> selectEven(ArrayList<Integer> listHuge) {
ArrayList<Integer> listSmall = new ArrayList<>();
//遍历大集合元素
for (int j = 0; j < listHuge.size(); j++) {
//判断是否为偶数
if (listHuge.get(j) % 2 == 0) {
//偶数添加到小集合中
listSmall.add(listHuge.get(j));
}
}
return listSmall;
}
}
ArrayList是接口List的实现类
List接口的方法依然有add、get
常用API：String
java.lang.String类代表字符串
API中的描述：Java程序中的所有字符串字面值(如“abc”)都作为此类的实例实现
其实就是：程序中所有的双引号字符串，都是String类的对象（就算没有new，也照样是）
字符串的特点
- 字符串的内容永不可变
- 字符串是可以共享使用的(因为字符串不可改变，为节省性能，内容相同的字符串是进行共享的)
- 字符串效果上相当于char[]字符数组，但是底层原理是byte[]字节数组成
创建字符串的3+1种方式
三种构造方法：
- public String():创建了一个空白字符串，不含有任何内容
- pbulic String(char[] array):根据字符型数组的内容，来创建对应的字符串
- public String(byte[] array):根据字节型数组的内容，来创建对应的字符串
一种直接创建：
String str = “Hello”; //右边直接用双引号
字符串常量池：
程序当中直接写上的双引号字符串，就在字符串常量池中(new的不在池当中)
字符串常用的方法：
比较（equals()、equalsIgnoreCase()）、
获取（length()、concat(str)、charAt(index)、indexOf(str)）、
截取（substring(index)、substring(begin,end)）、
转换（toCharArray()、getBytes()、replace(oldStr, newStr)）、
分割（split(regex)）
字符串比较：
==是进行对象的地址值比较，如果要对字符串的内容进行比较，可以使用两种方法：
-
public boolean equals(Ojbect obj); 参数可以是任何对象，只有参数是一个字符串且内容相同才会返回true
注意事项：
-
任何对象都能用Object进行接受
-
equals方法具有对称性，即a.equals(b)和b.equals(a)效果一样
-
如果比较双方一个常量一个变量，推荐把常量字符串写在前面
推荐：“abc”.equals(str) 不推荐：str.equals(“abc”) (原因：变量可能为null，调用时会出现空指针异常)
-
-
public boolean equalsIgnoreCase(String str):忽略大小写，进行内容比较
与获取相关的常用方法：
- public int length()：获取字符串当中含有的字符个数
- public String concat(String str):将当前字符串和参数字符串拼接成为新的返回值字符串
- public char charAt(int index):获取指定索引位置的单个字符
- public int indexOf(String str):查找参数字符串在本字符中首次出现的索引位置，如果没有则返回-1
字符串的截取方法
-
public String substring(int index):截取从参数位置一直到字符串末尾，返回新字符串
-
public String substring(int begin, int end):截取从begin开始，一直到end结束，中间的字符串
字符串转换相关的常用方法
-
public char[] toCharArray(); 将当前字符串拆分为字符数组作为返回值
-
public byte[] getBytes(); 获得当前字符串底层的字节数组
-
public String replace(CharSequence oldString, CharSequence newString); 将所有出现的老字符串替换成新的字符串，返回替换只有的结果新字符串
备注：CharSequence意思是可以接受字符串类型
分割字符串的方法：
public String[] split(String regex); 按照参数的规则，将字符串切分成为若干部分
注意：split方法中的参数其实是正则表达式，要想切割".“需要写”\\."(两个反斜杠)
字符串相关示例
拼接字符串定义一个方法，把数组{1, 2, 3}按照指定格式拼接成一个字符串。格式参照如下：[word1#word2#word3]
public class TestConcat {
public static void main(String[] args) {
//创建一个数组对象
int[] array = {1, 2, 3};
//调用自定义方法
String result = myConcat(array);
//显示结果
System.out.println(result);
}
public static String myConcat(int[] array) {
//拼接左括号
String result = "[";
for (int i = 0; i < array.length; i++) {
if (i < array.length - 1) {
//拼接中间部分
result += "word" + array[i] + "#";
} else {
//拼接尾部
result += "word" + array[i] + "]";
}
}
return result;
}
}
键盘输入一个字符串，并且统计其中各种字符出现的次数（种类有：大写字母、小写字母、数字、其他）
import java.util.Scanner;
public class testStatic {
public static void main(String[] args) {
//从键盘接收数据
System.out.print("请输入一串字符： ");
String str = new Scanner(System.in).next();
//初始化各种类型数量为0
int bigChar = 0;
int smallChar = 0;
int numChar = 0;
int otherChar = 0;
//将字符串转为数组方便统计
char[] ch = str.toCharArray();
//统计
for (int i = 0; i < ch.length; i++) {
if (ch[i] >= 'A' && ch[i] <= 'Z') {
bigChar++;
} else if (ch[i] >= 'a' && ch[i] <= 'z') {
smallChar++;
} else if (ch[i] >= '0' && ch[i] <= '9') {
numChar++;
} else {
otherChar++;
}
}
System.out.println("大写字母：" + bigChar + '个');
System.out.println("小写字母：" + smallChar + '个');
System.out.println("数字：" + numChar + '个');
System.out.println("其他：" + otherChar + '个');
}
}
常用API：Arrays
java.util.Arrays是一个与数组相关的工具类，厘米提供了大量静态方法，用来实现数组常见的操作
数组转字符串
public static String toString(数组); 将参数数组变成字符串 (按照默认格式：[元素1， 元素2， 元素3 …])
数组排序
public static void sort(数组); 按照默认升序（从小到大）对数组的元素进行排序
备注：1. 如果是数值，sort默认按照升序从小到大
2. 如果是字符串，sort默认按照字母升序
3. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持
示例：
使用Arrays相关的API,将一个随机字符串中的所有字符升序排列，并倒序打印
import java.util.Arrays;
import java.util.Random;
public class TestArrays {
public static void main(String[] args) {
//随机字符串
String rd = "";
for (int i = 0; i < 10; i++) {
Random r = new Random();
rd += (char)(r.nextInt(26) + 97);
}
//显示生成的随机字符串
System.out.println("随机字符串为： " + rd);
//字符串转数组
char[] charArray = rd.toCharArray();
//升序排序字符数组
Arrays.sort(charArray);
//倒序打印
for (int i = charArray.length - 1; i >= 0; i--) {
System.out.print(charArray[i]);
}
}
}
常用API：Math
java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作
常用方法
public static double abs(double num); 获取绝对值 【有多种重载】
public static double ceil(double num); 向上取整
public static double floor(double num); 向下取整
public static long round(double num); 四舍五入
Math.PI
代表近似的圆周率Π常量
示例
计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？
public class TestMath {
public static void main(String[] args) {
double min = -10.8;
double max = 5.9;
int count = 0;
for (int i = (int)Math.ceil(min); i < max; i++) {
if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
count++;
System.out.print(i + " ");
}
}
System.out.println("总共有： " + count);
}
}
匿名对象（Anonymous）
正常创建对象格式：
类名称 对象名称 = new 类名称();
匿名对象就是只有右边的对象，没有左边的名称和赋值操作
new 类名称();
注意事项：匿名对象只能使用唯一的一次，下次再用不得不创建一个新对象
使用建议：如果确定有一个对象只需要使用唯一的一次，就可以用匿名对象
static关键字
修饰成员变量：
一旦用了static关键字，内容将属于类，而不再属于自己，所以凡是本类对象都共享一份，存于方法区
修饰成员方法：
一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的
修饰代码块：
静态代码块格式：
public class 类名称 {
static {
//静态代码块的内容
}
}
特点：
-
当第一次用到本类时，静态代码块执行唯一的一次
2. 静态代码块比构造方法先执行
静态代码块的典型用途：
用来一次性地对静态成员变量进行赋值
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它
如果有了static关键字，那么不需要创建对象，直接通过类名称就能使用
使用推荐：
无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称来进行调用
静态变量：类名称.静态变量
静态方法：类名称.静态方法
注意事项：
-
静态不能直接访问非静态
内存中先有的静态内容，而非静态内容创建对象后才会出现在内存中
-
静态方法不能使用this
this代表当前对象，通过谁调用的方法，谁就是当前对象
对public、private、static关键字的理解：
public：让修饰成员变量和方法可见，正常情况只有在同一个包下才能进行调用，
public修饰目的：调用方法或成员变量不在同一个包时，让其依旧能够生效
static：静态化修饰的成员变量和方法，正常情况变量和方法都是对象独有的，即每个对象都保留有一份互不干扰
static修饰目的：
1. 让成员变量和方法在内存中只保留一份，所有对象共用(因此可直接类名.方法 调用)
2. 程序一开始就会在内存中生成，因此在类中可直接调用，而不必通过创建对象来调用
private：私有化成员变量，正常情况下同一个包下是可以直接修改数据(public修饰过的，挎包也能)
private修饰目的：让成员变量在类以外的任何地方都无法修改，只能通过调用方法来修改，保护数据
总结：
- public让包外也可使用；
- private让包内也不可用；
- static让只有一份存于方法区、不创建对象也能用(用类名称)
final关键字
final关键字代表最终、不可改变的意思
常见四种用法：
-
可以用来修饰一个类
-
可以用来修饰一个方法
-
可以用来修饰一个局部变量
-
可以用来修饰一个成员变量
final关键字修饰一个类
格式如下：
public final class 类名称 {
//...
}
含义：当前这个类不能有任何的子类
注意：
如果一个类是final的，那么其中所有的成员方法都无法进行覆盖重写(没子类，无继承关系，所以不可能覆盖)
final关键字修饰一个方法
格式如下：
修饰符 final 返回值类型 方法名称(参数列表) {
//...
}
含义：当final修饰一个方法时，这个方法就是最终方法，不能被覆盖重写
注意事项：
对于类、方法来说，abstract关键字和final关键字冲突，不能同时使用(abstract一定会覆盖重写，final表示不能)
final关键字修饰一个局部变量
格式： 直接在变量类型前加上final即可
含义：一旦使用final来修饰局部变量，那么这个变量就不能进行更改(一次赋值，终生不变)
注意事项：
-
对于基本类型：不可变说的是变量中的数据内容不可变
-
对于引用类型：不可变说的是变量中的地址值不可变，但是地址对应的对象中保存的内容是可以改变的
-
基本类型使用final时，变量的声明与初始化分开也是允许的，只要保证变量只被赋值一次即可
import java.util.Arrays; public class FinalLocalVariable { public static void main(String[] args) { final int num1 = 10; // num1 = 20; //改变变量保存到数据内容，编译报错 //正确写法，变量只被赋值了一次 final int num2; num2 = 20; final int[] arrayInt = new int[] {1, 2, 3}; System.out.println(Arrays.toString(arrayInt)); //[1, 2, 3] // arrayInt = new int[] {2, 3, 4}; //改变变量保存的地址，编译报错 arrayInt[0] = 2; //改变变量保存地址中对象的数据，正常运行 System.out.println(Arrays.toString(arrayInt)); //[2, 2, 3] } }
final关键字修饰一个成员变量
格式：直接在变量类型前加上final即可
含义：使用final关键字后，被修饰的变量不可变
注意事项：
-
注意与局部变量的区别，成员变量具有默认值，用了final之后必须手动赋值，避免默认赋值，否则编译报错
（因为final修饰后变量只能被赋值一次，若是被赋予默认值，之后再也无法改变，这个变量无任何意义）
-
final修饰的成员变量，赋值时直接通过直接赋值或通过构造方法赋值，必须二选一，不能等待赋予默认值
A. 直接赋值：final修饰语句后面立刻赋值，不能声明与初始化分开
public class FinalMemberVariable { private final String name = "xxx"; /* //分开写法，编译报错 private final String sex; sex = "***" */ public FinalMemberVariable() { } /* public FinalMemberVariable(String name) { this.name = name; //已经选择了直接赋值，再在构造方法中赋值，重复修改数据，编译报错 } */ public String getName() { return name; } }B. 通过构造方法赋值：final修饰后不直接赋值，在构造方法中对其赋值，构造方法的每一个重载中都要赋值
public class FinalMemberVariable { private final String name; /* public FinalMemberVariable() { } //选择构造方法赋值时，此构造中未进行赋值，编译报错 */ public FinalMemberVariable(String name) { this.name = name; } public String getName() { return name; } } -
构造方法以外的所有方法，对被final修饰的成员变量进行赋值操作，会全部编译报错
public class FinalMemberVariable { private final String name = "xxx"; public FinalMemberVariable() { } public String getName() { return name; } /* public void setName(String name) { this.name = name; //不是两种赋值方式的任何一种，对其进行赋值，编译报错 } */ }
Java的四种权限修饰符：
| 不同包/不同修饰符 访问权限 | public | > | protected | > | (default) | > | private |
|---|---|---|---|---|---|---|---|
| 同一个类(我自己) | YES | YES | YES | YES | |||
| 同一个包(我领居) | YES | YES | YES | NO | |||
| 不同包子类(我儿子) | YES | YES | NO | NO | |||
| 不同包非子类(陌生人) | YES | NO | NO | NO |
简单一点就是：
| 能够使用的范围 | 使用方式 | |
|---|---|---|
| (default) | 默认包下所有 | 本类直接通过变量名使用，包下其他类通过创建对象.变量名使用 |
| private | 局限到本类 | 本类直接通过变量名使用 |
| protected | 扩展至包外子类 | 包下的使用方式与默认一致，包外的子类通过super.变量调用，(不能在子类中通过创建父类对象来直接调用，编译报错) |
| public | 扩展到包外所有 | 包下的使用方式与默认一致，包外子类可通过super.变量调用，也可以创建父类对象直接调用，包外非子类通过创建父类对象直接调用 |
总结：
-
在同一个包中，类中的protected或default修饰的变量或方法可以在类外被其对象(实例)外部访问，可以以被子类继承。此时，protected或default的访问级别与public相同
-
在不同的包中，类中的protected修饰的变量或方法在类外不可用被其对象(实例)外部访问，可以被子类继承。类中的default修饰的变量或方法在类外，不可以被子类继承，此时的default相当于private
-
protected和private是针对成员的修饰
外部类与内部类：
如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类
例如：身体与心脏，汽车与发动机
分类：
- 成员内部类
- 局部内部类（包含匿名内部类）
成员内部类
成员内部类定义格式：
修饰符 class 外部类名称 {
修饰符 class 内部类名称 {
//...
}
//...
}
注意：内用外，随意访问；外用内，需要创建内部对象
使用成员内部类的两种方式：
-
间接方式：在外部类的方法当中，创建内部类对象进行使用；然后main中调用外部类的方法
-
直接方式，套用公式:
//创建外部类格式 类名称 对象名 = new 类名称(); //创建内部类格式 外部类名称.内部类名称 内部类对象名 = new 外部类名称().内部类名称();
成员内部类的同名变量访问：
如果出现了重名现象，内部类的方法内调用外部类变量的格式为：
外部类名称.this.外部类成员变量名
示例如下：
public class Outer {
int num = 30; //外部类成员变量
public class Inner {
int num = 20; //内部类成员变量
public void method() {
int num = 10; //内部类局部变量
System.out.println(num); //使用内部类局部变量
System.out.println(this.num); //使用内部类成员变量
System.out.println(Outer.this.num); //使用外部类成员变量
}
}
}
public class Demo {
public static void main(String[] args) {
Outer.Inner inner = new Outer().new Inner();
inner.method();
}
}
局部内部类
如果一个类定义在一个方法内部的，那么这就是一个局部内部类
局部：只有其所属的方法才能使用，出了方法外面就不能用
局部内部类定义格式：
修饰符 class 外部类名称 {
修饰符 返回值类型 外部类方法名称(参数列表) {
class 内部类名称 {
//方法体
}
}
}
注意事项：
局部内部类，如果希望访问所在方法的局部变量，必须保证这个局部变量是有效的final（即只赋值过一次）
备注：从Java 8开始，只要局部变量事实不变(只赋值一次)，那么关键字final可以省略
要求final的原因：
1. new出来的对象放在堆区中
2. 局部变量跟着方法走，存放在栈区
3. 方法运行结束，立刻出栈，局部变量立刻消失
4. 堆区中的对象生命周期更长，若给的是变量，数据已经被销毁，此时在对其进行操作会出现问题
权限修饰符使用情况：
public > protected > (default) > private
定义一个类的时候，权限修饰符：
- 外部类：public / (default)可用
- 成员内部类：public / protected / (default) / private全都可用
- 局部内部类：什么都不能写（与(default)存在很大区别，(default)的同一个包下都能用，而此处什么都不写代表的是只有方法内可用）
匿名内部类
如果接口的实现类(或者是父类的子类)只需要使用唯一的一次，
那么这种情况下就可以省略该类的定义，而改为使用匿名内部类
匿名内部类的定义格式：
接口名称 对象名 = new 接口名称() {
//覆盖重写所有抽象方法
}; //不要忘了分号
示例如下：
//定义一个接口
public interface MyInterface {
void method();
}
//定一个实现类，以供常规写法显示对比
public class MyInterfaceImpl implements MyInterface {
public void method() {
System.out.println("实现了抽象方法");
}
}
public class DemoMain {
public static void main(String[] args) {
//常规写法
MyInterface obj = new MyInterfaceImpl();
obj.method();
//使用匿名内部类
MyInterface obj1 = new MyInterface() {
@Override
public void method() {
System.out.println("匿名内部类覆盖重写");
}
}; //匿名内部类这种方式，就省去了一个实现类单独定义的步骤
obj1.method();
}
}
匿名内部类解析：
对格式"new 接口名称() {…}"进行解析
- new：代表了创建对象动作
- 接口名称：就是匿名内部类需要实现的接口
- {…}：这才是匿名内部类的内容
注意事项：
-
匿名内部类，在创建对象的时候，只能使用唯一一次
如果希望多次创建，且内容一样，必须使用单独定义的实现类， 否则只能内容完全一样重复写，代码冗余
//使用匿名内部类定义一次 MyInterface obj1 = new MyInterface() { @Override public void method() { System.out.println("匿名内部类覆盖重写"); } }; //要再次使用时，必须再次定义 //MyInterface obj2 = new MyInterface(); //这样会编译报错 -
匿名对象，在调用方法的时候，只能调用唯一一次
如果希望同一个对象，调用多次方法，必须给对象起名字
-
匿名内部类是省略了实现类/子类名称，但是匿名对象是省略了对象名称
类可以作为成员变量类型
接口可以作为成员变量类型