一、Java入门
常用dos命令
返回上一级 cd..
进入文件夹:cd 文件名
盘符切换:盘符:
查询所在文件夹所有文件:dir
新建文件: cd>文件全名
删除文件:del 文件全名
新建文件夹:md 文件夹名
移除文件夹:rd 文件夹名
清屏: cls
退出窗口: exit
查看电脑IP:ipconfig(需管理员权限)
打开应用:
计算器: calc
画图: mspaint
新建记事本:notepad
网址IP获取:ping 网址
1、java的特性和优势
-
简单性
-
面向对象
-
可移植性
-
高性能
-
分布式
-
动态性
-
多线程
-
安全性
-
健壮性
2、java的三大版本
JavaSE:标准版(桌面程序、控制台开发…)核心
JavaME:嵌入式开发(手机、家电…)夕阳红
JavaEE:E企业级开发(web开发、服务器开发)使用量三者最高
3、JDK、JRE、JVM
-
dk:java代码工具(编译)
-
jre:java的运行环境(生存)
-
jvm:实现java跨平台的核心
**三者关系:**jdk<jre<jvm
4、JDK的安装与配置
详情点这里
一次配置,理论永久使用。
- 安装配置玩之后,一定要检测:打开dos命令框:java version
- 成功图:(有问题在去点一下“这里”)[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j9op53Ax-1594649177288)(C:\Users\000\AppData\Roaming\Typora\typora-user-images\image-20200713095620975.png)]
有些坑,不去走一遭,你永远不会知道,里面的世界有多精彩。
- 有助于记忆加深
5、java的运行机制
-
手动写出的代码
-
通过java编译器编译后
-
生成计算机可以理解的数据文件
-
通过jvm的解释给计算机执行
二、java基础
1、注释
//单行注释
②多行注释
/*
多行注释
*/
③文档注释
/**
* 文档注释
*
* */
2、标识符、关键字、数据类型
①标识符命名规则
-
以字母(大小写)、美元符($)、下划线(_)开始。
-
首字母以后可以是字母大小写、美元符、下划线或任何数字组合。
-
不能使用关键字作为标识符。
-
表示符要严格区分大小写。
②关键字1
③数据类6型
数据类型分为两大种:基本数据类型、引用数据类型
基本数据类型(primitive type)
-
整数类型
- byte
-
short
- int (默认值为0)
-
long :
long l=100l;//使用时须在赋值末尾加上'L'声明。
*进制:注意看整数的本身和开头
二进制(0b开头)、八进制(0开头)、十进制 、十六进制(0x)
-
浮点类型2
-
float
float f=3.14f;//使用时必须在赋值末尾加上'F'声明。
-
double(默认值为0.0)
-
-
字符型
-
char:长度占2个字节
-
dhar c='A'; //char类型是可以运算的因为char在ASCII等字符编码表中,有对e应的数值。对char类型字符运行时,直接当做ASCII表对应的整数来对待。
-
-
-
boolean类型
-
默认值为flase,只有两个值(flase、true)
boolean b=fiase; boolean d=flase; System.out.println(d==b); //两个boolean数据对比时,同为flase、true时结果就为true,反之不同则为flase。
-
引用数据类型3 (reference type)
-
类
-
接口
-
数组
*字节:
-
位(bit):是计算机内部数据储存最小的单位,习惯用小写b表示。
-
字节(byte):是计算机中数据处理的基本单位,习惯用大写B来表示。
-
1B=8bit、1k=1024B
*字符:
- 是指计算机中使用的字母、数字、字、符号、
3、数据类型转换
类型转换(两种)
①自动装换:由高到度
②强制装换:由低到高
int i1=10;
byte b=(int)i1;
*注意
-
boolean不能转换
-
不能瞎转(一个胖子通过减肥可以成为瘦子,无法变成牲口不是)
-
转换过程中可能存在内存溢出、精度丢失的问题!
内存溢出案例
// 数据类型的转换
//年薪
int i1=10_0000_0000;//jdk7版本的新特性数字中加入下划线不会影响输出方便数数。
//工作年数
int i2=20;
// 计算工资总和(一)
System.out.println("计算工资总和(一)");
int i3=i1*i2;
System.out.println(i3)
//输出结果:-1474836480
//结果数据溢出数据类型最大值
System.out.println("计算工资总和(二)");
long l1=i1*i2;//计算的时候已经溢出
System.out.println(l1);
//输出结果还是:-1474836480
//结果还是不对,原因:代码执行的顺序,先计算,在赋值,在计算过后得出的还是int类型
System.out.println("(三)");
long l2=i1*(long)i2;
System.out.println(l2);
//输出结果:20000000000
//答案正确
精度丢失案例
//精度丢失案例
double d33=3.1;
int i=(int)d33;
System.out.println(i);
//输出结果:3
4、变量、常亮、作用域
- 修饰符的顺序,对代码的运行没有影响。
常量:(关键修饰符 final)
-
初始化后不能在改变!!!
//语法示例: final int aa=1;
变量:
牵扯到空间分布,后头补上
//语法示例:
String name ;
int age;
double dd;
char cc;
boolean bb;
-
局部变量:在方法内声明的变量,必须初始化,才可以调用。作用域:最近的一组大括号内。
-
实例变量:从属于对象,不初始化的话,是默认为数据类型的默认值。(在方法体内new出,才可以调用)
-
类变量:在对象主方法内用static修饰符,修饰的变量。(可以在全文内直接调用!)
//示例: static String xm="lyx";
变量的命名规范
作用域:
- 代码的作用(生存)范围
5、运算符
①算术运算符
-
+、-、*、/、%、++、–
-
++、–运算符:运算符在前,先赋值在运算,在后先运算在赋值
//示例:
int i=4;
int p=i++;//++在前先赋值在运算。
System.out.println(i);
int q=++i;//++在后先运算在赋值。
System.out.println(p);
System.out.println(q);
//输出:4、6
②赋值运算符:
-
=
-
运算顺序是从左往右的顺序,把运算符左边的值赋值给运算符右侧。
③关系运算符
-
‘>’、<、<=、>=、==、!=
-
前四个和数学同义
-
**==:**两个数字比较是否相等的运算符
-
**!=:**表示不等的关系运算符。
④逻辑运算符
- && 、||、 ! 分别对应与、或、非(反意)
Boolean a=false;
Boolean b=true;
System.out.println("a&&b:"+(a&&b));
//运算符两侧都为true,结果才为true,如果右侧为false,则不再计算左侧真假。
System.out.println("a||b:"+(a||b));
//运算符两侧有一侧为true,结果就为true;如果右侧为true,则不再计算左侧真假。
System.out.println("!(a||b):"+!(a||b));
/* 输出:a&&b:false
a||b:true
!(a||b):false
*/
⑤位运算符
-
&、|、^、~、<<、>>、>>>(用于二进制运算)
-
位运算效率较高
/*
A = 0011 0100`在这里插入代码片`
B = 0100 1101
------------------------
A&B = 0000 0100 //两个同位数二进制数字,对比同位数的数字是否相同 相同为1,否则取0。
A|b = 0111 1101 //两个同位数二进制数字,对比同位数的数字是否相同 从同为0,不同为1。
A^B = 0111 1010 //两个同位数二进制数字,对比同位数的数字是否相同 相同为0,不同为1。
~B = 1011 0010 // 相对于B取{0、1}的反值(1取0,0取1)
* */
- 面试题:高效计算2的3次方?
//高效计算2的3次方?
System.out.println(2<<3); //2在二级制里是0000 0010,16在二进制中是0001 0000,在2的基础上左移的3位//输出:16
⑥扩展运算符
-
+=、-=、*=、/=
int a=1; int b=2; b+=a;// b=b+a b-=a;// b=b-a b*=a;// b=b*a b/=a;// b=b/a System.out.println(b); }
⑦三元运算符
//格式:条件?结果1:结果2;
int a=6;
String s=a>10?"大于10":"小于10";
System.out.println(s);
//输出:小于10
⑧包机制
- 一般利用公司域名倒置作为包名。
⑨javaDoc
- 用来生成自己APL文档
三、工具类
①输入函数Scanner4
-
//语法: Scanner sc = new Scanner(System.in); String name = sc.next(); sc.close();//关闭IO流节约资源。
-
通过Scanner类中next()与nextLine()方法获取控制台输入的字符串。
-
next()与nextLine()方法的区别:前者默认空格运行到空格停止接收,而后者运行到空格,继续接受空格后的数据。
四、结构
①顺序结构
-
最基本的算法结构
-
语句与语句,框与框从上到下的顺序一一执行
System.out.println("1111"); System.out.println("2222"); System.out.println("3333"); System.out.println("4444"); System.out.println("5555"); /*输出:1111 2222 3333 4444 5555 */
②单、双、多if结构
-
单选择
if(boolean表达式){ //如果Boolean结果为true,将会执行循环体内的语句。 }
-
双选择
if(boolean){ //如果Boolean结果为true,将会执行这个循环体内的语句。 }else{ // 如果Boolean结果为false,将会执行这个循环体里的语句。 }
-
多选择
if(boolean1){ //如果Boolean结果为true,将会执行这个循环体内的语句,并结束跳出if判断语句! //如果为false则继续按照顺序结构接着往下运行。 }else if(boolean2){ //如果Boolean2结果为true,将会执行这个循环体里的语句,并结束跳出if判断语句! //如果为false则继续按照顺序结构接着往下运行。 }else if(boolean3){ //如果Boolean3结果为true,将会执行这个循环体里的语句,并结束跳出if判断语句! //如果为false则继续按照顺序结构接着往下运行。 }else{ //如果上方Boolean(1~3)结果都为false,将会执行这个循环体里的语句,并结束跳出if判断语句! }
③Switch选择结构
//语法示例
System.out.println("请输入大于0小于6的int:");
Scanner scanner = new Scanner(System.in);
int sc=scanner.nextInt();
//switch循环:匹配一个值。
//能够使用的变量类型:byte、short、int、char、String(五种)
switch (sc){
//case标签只能接收字符串常亮或字面量
case 1://匹配条件标签
System.out.println("输入的是"+sc);
break;//跳出循环
case 2:
System.out.println("输入的是"+sc);
break;
case 3:
System.out.println("输入的是"+sc);
break;
case 4:
System.out.println("输入的是"+sc);
break;
case 5:
System.out.println("输入的是"+sc);
break;
default://以上case都没有匹配成功,执行这里的代码!
System.out.println("输入超出范围!");
}
④循环结构(while、do…while、for)
-
while循环
//语法: while (boolean表达式){ //当boolean表达式结果为false时break }
-
do…while循环
- 先循环、后判断。
int a=1; do { a++; }while (a<1); System.out.println(a); //输出:2
-
For
for (初始变量;boolean表达式;递归){ // bolean表达式结输出为ture,执行这里的代码,为false,退出 }
*嵌套
-
与多选择结构相比,嵌套运算要快很多
-
所有的语句、循环都可以嵌套使用
//嵌套的if结构示例 int i=11; if(i>5&&i<20){ if(i>10&&i<20){ System.out.println("i="+1); } }
五、方法
-
命名:小驼峰命名规则
-
理解:方法包含在对象或类中,在程序中被创建,在其它地方被引用。
-
原则:保持原子性,一个方法只能完成一个功能,便于后期的扩展。
①定义:
//方法的定义
修饰符 返回值类型 方法名(参数){
//形式参数:接受传递给方法的数据。 实参:传如方法的数据
方法体。
return 返回值;//不需要返回之时,需要void声明
}
②调用:
public static void main(String[] args) {
a();
}
//创建一个输出“已调用”字符的方法a
public static void a(){
System.out.println("已调用");
}
//在方法内使用static修饰符的方法,可以直接调用
//没有static修饰的方法,需要先new到方法所在的类
③重载:
-
规则: 方法名必须 一致、参数的属性不能一致。
-
实现理论: 方法名相同时,编译器会根据方法参数的个数、位置、类型等逐个去配对,选择方法。(如果都匹配不上,则编译器报错)
public static void main(String[] args) { add(1,3); add(1.5,1.2); } public static void add(int i,int a){ System.out.println(i+a); } public static void add(double i,double a){ System.out.println(i+a); } //输出:4 2.7 }
④可变参数:
//可变参数 such:这样的
// 可变参数:必须在参数栏最后,声明方法:参数类型... name(三个英文句号 ),接受的数据类型必须一致。
public static void such(int... i){
// 通过下标匹配
System.out.println(i[0]);
}//输出:1
⑤递归
-
结构:
- 递归头:什么时候不调用自身的方法,如果没有头,将陷入死循环。
- 递归体:什么时候需要调用自身的方法。
-
定义示例:
//一般而言,兔子在出生两个月后,就有繁殖能力,一对兔子每个月能生出一对小兔子来。如果所有兔子都不死,那么一年以后可以繁殖多少对兔子? public static int Dome12(int i){ if (i==1) { return 1; } else if(i==2){ return 2 ; }else { return Dome12(i-2)+Dome12(i-1); }
六、数组
1.特点
-
数组是相同数据类型(包括引用类型)的有序集合
-
数组的大小初始化之后 无法更改 。
-
数组元素类型必须一致, 不能出现混合类型 。
-
数组对象本身是在堆中。
-
数组也是对象,数组元素相当于对象的成员变量。
2.语法
//数组的创建
int[] add;//常用的创建方法
int aaa[];//不常用的创建方法
//数组的初始化
add =new int[10];
- .length:获取数组下标
3.初始化
//动态初始化:先声明一个数组并分配空间,在逐一赋值
int[] a1=new int[10];
a1[0]=1;
//静态初始化:声明一个数组,并填充数组数据
int [] a2={1,2,3,4,5,6,7,8,9,10};
//默认初始化:声明数组、分配空间,不赋值,数组元素默认为 类型默认值
int[] a3 =new int[10];
4.内存分析
5.数组的使用
/* 1,for循环打印、获取等操作数组
2.for-each循环遍历出数组,无法获取下标等操作数组
3,数组入参
4,数组作返回值
* */
public static void main(String[] args) {
int[] a={1,2,3,4,5,6,7,8,9,10};
add(add3(a));
}
//遍历出数组的方法
public static void add(int[] i){
for (int s:i){
System.out.println(s);
}
}
//数组做返回值 计算数组和
public static int add2(int[] i){
int a=0;
for (int b=0;b<i.length;b++){
a+=i[b];
}return a;
}
//数组翻转
public static int[] add3(int[]i){
int[] a =new int[i.length];
for(int e=0,t=i.length-1;e<i.length;e++,t--){
a[t]=i[e];
}
return a;
}
6.二维数组
//二维数组:数组套数组,数组里的每一个数组元素,都是一个数组
int[][] a={{1,2},{3,4},{5,6}};
//遍历方法
System.out.println(a[0][1]);
//第一个[]是大数组元素的下标,第二个[]是小数组的下标。
//输出2
7.Arrays工具类
-
数组的工具类java.util/Arrays
-
Arrays类中的方法都是static修饰的静态方法,可以直接只用类名调用,也可以使用对象调用
-
Arrays类中常用方法:
-
toString();打印数组
-
fill();数组填充
-
sourt();升序排列数组元素。
-
equals();比较熟组中元素值是否相等。
-
8.稀疏数组
七、OOP(面向对象)
-
属性加方法就是一个类。
本质:以类的方式组织代码,以对象的组织(封装)数据。
-
三大特性:封装、继承、多肽。
1、方法定义;
修饰符 返回值类型 方法名(参数){
方法体
return 返回值;
}
2、方法的调用;
1.实例化:
//java中类的实例化是通过new关键字来实现的。
//对象类型 对象名=对象值;
//非静态方法的调用方式
Dome01 d=new Dome01();
d.stu2();
// 静态方法的调用
Dome01.stu1();
2.静态与非静态方法的加载时机
//静态方法,和类一起加载的
public static void cc(){
//!aa();异常
//因为aa();是类被实例化的时候加载,所以报错、
}
//非静态方法,在类被实例化的时候加载的
public void aa(){
bb();
}
public void bb(){
}
3.形参与实参
- 形式参数要和实际参数要一致。
public static void main(String[] args) {
Dome03 d = new Dome03();
//实参:调用方法是传入的参数
d.add(1,2);
}
//形参:新建方法时传入的参数
public void add(int a,int b){
System.out.println(a+b);
}
4.值传递、引用传递
-
**值传递:**bai传递是指在调用函数时将实du际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数。
-
**引用传递:**接把内存地址传过去,也就是说引用传递时,操作的其实都是源数据,
3、类与对象的创建
1.new:
- 使用new关键字创建的时候,除了分配空间,还会给创建好的对象,进行初始化以及对类中构造器的调用
2.类的创建
public class Stu {
//创建类:类是由属性和方法组成的
//声明方法:修饰符 class关键字 类名{}
//创建一个stu学生类,还有姓名、年龄的属性,学生玩手机的方法。
String name;//姓名
int age;//年龄
//学生玩手机的方法
public static void stu_add(){
System.out.println("学生玩手机!");
}
}
3.对象的创建
//创建对象对象:类是抽象的,类实例化后会返回一个自己的对象。
//stu对象就是Stu类的具体实例化。
//创建对象示例
public static void main(String [] args){
Stu stu = new Stu();
stu.name="张三";
stu.age=15;
System.out.println(stu.name);
System.out.println(stu.age);
stu.stu_add();
}
4.构造器
public class Dome01 {
/*
1、当类中没有构造方法的时候,idea会帮我们自动生成一个默认无参构造器
2、但是如果在类中声明了有参构造器,idea就不在帮我们自动生成无参构造器
3、构造器的特点:1.构造器名必须与类名一致
2.构造器不能有返回类型和void
4、构造器的作用:1.new的本质是调用构造器
2.初始化对象的值。
*/
public String name;
public int age;
public Dome01() {
}
public Dome01(String name, int age) {
this.name = name;
this.age = age;
}
}
public static void main(String[] args) {
//使用new关键字实例化Dome01类
Dome01 dome01 = new Dome01("张三",219);
System.out.println(dome01.name);
System.out.println(dome01.age);
}//输出:张三
219
* 小结:
1.类是模板、抽象的,对象是一个具体的实例。
2.方法:定义与调用
3.对应的引用:
-
引用类型、基本类型
-
对象是通过引用来操作的,是由栈指向堆
4.属性:字段final,成员变量
-
默认初始化:
-
数字:0、0.0
-
char:u0000
-
boolean:false
-
引用:null
-
5.对象的创建和使用
-
对象必需要通过关键字new来创建,构造器 类 对象名=new 类();
-
对象的属性:对象名.类中属性名
-
对象的方法:对象名.类中方法
6.类:
- 静态属性:属性
- 动态行为:方法
4、封装
-
封装是一种隐藏技术,面向对象方法的重要原则,就是把对象的属性和操作(或服务)结合为一个独立的整体,并尽可能隐藏对象的内部实现细节。
-
作用:增强了程序的 把对象的私有数据和公共数据分离开,保护了私有数据,减少了可能的模块间干扰,达到降低程序复杂性、提高可控性的目的。
4.1、封装示例
//封装:关键修饰词 private:私有 Get'set 方法
public class Dome02 {
//private修饰的属性或方法,只能在本类中引用
private String name;
private char sex;
private int age;
//get \set方法
//(获取、设置)
public String getName() {return name; }
public void setName(String name) {this.name = name; }
public char getSex() {return sex; }
public void setSex(char sex) {this.sex = sex; }
public int getAge() {return age; }
public void setAge(int age) {this.age = age; }
}
4.2、封装的调用
public static void main(String[] args) {
//实例化封装类
Dome02 dome02 = new Dome02();
//调用封装类中,设置属性值的方法。
dome02.setName("张三");
//调用封装类中,获取属性值的方法。
System.out.println(dome02.getName());
}
5、继承
1.关键字extends示例:
- 私有属性、方法无法继承
- 在子类的无参构造器中,调用自身或父类的无参构造器,必须在第一行,不能同时存在。
//Dome03类继承了Dome02类
public class Dome03 extends Dome02{
}
//此时Dome02就是Dome03的父类(基类),Dome03就是子类(派生类)
//一个父类可以有多个子类,但是一个子类只能有一个父类。
2.Object祖父类
- Object是所有类的父类,任何类都默认继承Object。
6.super与this的用法
###1.注意点:
-
1.super调用父类的构造方法,必须在构造方法的第一个。
-
2.super必须只能出现在子类的方法或者构造方法中!
-
3.super和this 不能同时调用构造方法!
2.代表对象不同:
- this :调用自身
- super:调用父类
###3 .前提:
- this:没有继承也可以使用
- super:需要继承了父类才可以调用
4.构造方法:
- this();引用本身的构造。
- super();引用父类的构造。
7、方法重写
7.1、为什么需要重写
- 父类的功能子类不一定需要和满足!
7.2、重写规则
-
必须要在有继承关系的前提下,子类重写父类的方法。
-
子类的重写方法必须与父类的方法一致,方法体不同。
-
方法名与参数列表必须一致。(参数列表不同就变成了重载)
-
修饰符:范围只能扩大,不能缩小(修饰符范围大小:public>Protected>Default(没有修饰符时,默认Default)>private)
-
抛出的异常:范围可以缩小,不能扩大。
-
idea重写快捷键:Alt键+Insete键 选择Override Methods
扩展:重写与重载的区别:
1.范围不同:重载的进行,是在同一个类中进行,而重写是子类重写父类的方法。
八、多态
-
理解:相同的操作,但是在不同的环境中用不同的作用,满足不同的需求。
-
一个对象的的实际类型是确定的,但可以指向对象的引用类型有很多种。【父类、有关系的类】
-
父类型引用子类型对象,可以直接调用子类重写的方法,还可以间接调用子类扩展方法
-
子类型对象,默认调用重写方法。
//调用示例 //父类型 对象名= new 子类型; Father s2 = new Son(); s2.方法名(); //调用子类扩展方法示例 ((Son)s2).子类扩展方法();
-
注意:
- 多态是方法的多态,属性没有多态。
-
前提:
- 继承关系
- 存在重写方法(static、final、private)静态、私有方法和常量不能重写
- 父类引用指向子类
8.1、instanceof、类型装换
public static void main(String[] args) {
Object object = new Son();
System.out.println(object instanceof Son);
System.out.println(object instanceof Father);
System.out.println(object instanceof Object);
System.out.println(object instanceof String);
System.out.println("=================");
Father father = new Father();
System.out.println(father instanceof Object);
System.out.println(father instanceof Father);
System.out.println(father instanceof Son);
}//输出结果: true
// true
// true
// false
// =================
// true
// true
// false
类型转换示例
//Father父类、Son子类、abb子类里中的扩展方法
public static void main(String[] args) {
//父类引用指向子类对象
Father son = new Son();
//调用子类扩展方法,需要大转小(强转)
//强转注意:可能会造成方法丢失
((Son)son).abb();
}
九、Static修饰符
9.1static属性
public class Stat_01 {
public static String naem;//静态变量
public int age;//非静态变量
public static void main(String[] args) {
System.out.println(Stat_01.naem);//从这里可以看到,在方法中可以直接调用static修饰的静态属性
// System.out.println(Stat.age);//却不能调用非静态的属性。
//非静态属性的调用
Stat_01 stat = new Stat_01();
System.out.println(stat.naem);
System.out.println(stat.age);
}
}
9.2、static方法
//Static 静态方法
public static void add(){
}
//非静态方法
public void aaa(){
}
public static void main(String[] args) {
//调用静态方法
add();//静态方法可以直接调用
//调用非静态方法
new Stat_02().aaa();//需要先 实例化建立通道才能使用。
}
9.3、string代码块
- 代码块与构造无参器的运行顺序
//static代码块
{
//代码块
System.out.println("常规代码块!");
}
//只执行一次
static{
System.out.println("static代码块!");
}
public Dome01() {
System.out.println("无参构造器!");
}
public static void main(String[] args) {
Dome01 dome01 = new Dome01();
}
//输出结果:static代码块!
// 常规代码块!
// 无参构造器!
十、抽象类
//抽象类;abstract
//意义:提高开发效率
public abstract class Dome_1 {
//abstract 类不能实例化,只能靠子类实现它,可以理解为:约束
//abstract 类中可以有方法
public void add(){
}
//抽象方法没有方法体,抽象方法只能在抽象类、接口中
public abstract void abb();
//抽象类也会自动生成无参构造器
}
十一、接口
- 接口可以理解为是一种约束、制度、规则。
1.接口示例:
//接口:interface 可以理解为是一种约束、制度、规则
//接口不能被实例化,没有构造方法。
public interface inteface__01 {
//接口属性:public static final变量的默认修饰符 --可以不写
public static final String name ="姓名";
//接口方法:只能有抽象方法 没有实现方法
// public、abstract是接口中方法的默认修饰 --可以省略。
public abstract void add();
void acc();
}
2.接口的实现
public class test implements inteface__01,inerface__02{
//implements可以继承多个接口
//继承接口必须要重写接口中的所有方法
@Override
public void add() {
}
@Override
public void acc() {
}
@Override
public void aaa() {
}
@Override
public void aff(){
}
}
八、内部类
1、声明示例:
public class Dome02 {
//外部类变量、方法
private int a=10;
public void name(){
System.out.println("外部类");
}
//声明一个内部类
public class Nei{
public void name2(){
//内部类可以直接引用外部类的私有方法、变量
System.out.println(a);
System.out.println("内部类");
}
}
}
2.调用示例
public class test1 {
public static void main(String[] args) {
//外部类的实例化
Dome02 dome02 = new Dome02();
//内部类需要通过外部类的对象来实例化
Dome02.Nei nei = dome02.new Nei();
//调用内部类方法
nei.name2();
}//输出结果:10、内部类
}
3.总结:
- 内部类需要通过外部类的对象来实例化。
- 内部类可以直接调用外部类的私有方法和变量。
九、异常机制
-
Throwable: 有两个重要的子类:Exception(异常)和 Error(错误)
- **Error(错误): **是程序无法处理的错误,表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关,而表示代码运行时 JVM(Java 虚拟机)出现的问题。
- **Exception(异常)😗*是程序本身可以处理的异常。
-
java异常结构层次图
9.1、示例
-
public static void main(String[] args) { int a=0; int b=1; try {//捕获异常的区域 System.out.println(b/a); }catch (ArithmeticException e){ //如果异常监控区,出现异常。则执行本代码块 System.out.println("代码异常!"); }finally{ //一定执行的代码块,可以省略不写 //多用于IO流的关闭资源。 System.out.println("Finally代码块"); } }
###9.2、异常类型获取
9.3、多异常
-
捕捉异常的顺序:由小到大
-
示例
try {//捕获异常的区域 System.out.println(b/a); }catch (ArithmeticException e){ //如果异常监控区,出现异常。则执行本代码块 System.out.println("代码异常!(ArithmeticException)"); }catch (Throwable t){ System.out.println("THrowable 异常提示!"); } finally{ //一定执行的代码块,可以省略不写 //多用于IO流的关闭资源。 System.out.println("Finally代码块"); }
9.4、idea快捷键
-
选中监控代码 ctrl+alt+T
9.5、throw、throws的使用
public void add(int a,int b)throws ArithmeticException{//方法上主动抛出异常:throws 异常类型
if (a==0) {
throw new ArithmeticException();//方法中主动抛出异常:throw new异常方法类型
}
9.6、自定义异常
- 自定义异常示例
public class exception_06 extends Throwable{
//自定义异常类(判断接收参数不能大于10)
private int a;
public exception_06(int i){
this.a=i;
}
//ToString打印方法
@Override
public String toString() {
return "exception_06{" + "a=" + a + '}';
}
}
- 验证自定义异常
//可能存在异常的方法
public static void s(int b) throws exception_06 {
System.out.println("参数:"+b);
if(b>10){
throw new exception_06(b);//抛出
}
System.out.println("ok");
}
public static void main(String[] args){
try {
s(14);
} catch (OOP_03.exception_06 e) {
System.out.println("exception_06-->"+e);
}
}//输出结果:参数:14
// exception_06-->exception_06{a=14}