Java基础语法
1. 注释、标识符、关键字
-
单行注释
//单行注释
-
多行注释
/*多行注释 */
-
文档注释
/**
*文档注释
*/
/** * 文档注释 * @Description HelloWorld * @Author xiaolong */
2.标识符、关键字
-
关键字
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RzifHgyB-1645348276335)(D:\Desktop\Java学习\img\关键字.png)]
-
标识符
- 所有标识符都必须以字母、美元符号、或者下划线开头
- 首字符之后可以是字母、美元符号、下划线或数字的任何组合
- 不能使用关键字作为变量名或者方法名
- 标识符大小写敏感
- 可以使用中文名
3.数据类型
-
强类型语言：所有变量必须先定义后才能使用
-
弱类型语言
-
Java的数据类型分为两大类
*基本类型
*引用类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zIh2tODF-1645348276336)(D:\Desktop\Java学习\img\数据类型.png)]
//八大基本数据类型
//整数
int num1 = 10;
byte num2 = 20;
short num3 = 30;
long num4 = 30L; //Long类型要在数字后加L
//小数：浮点数
float num5 = 10.1F //Float类型要在数字后加F
double num6 = 3.1426926789
//字符
char name = 'A'
//字符串，String不是关键字，是类
String name = "xiaolong"
//布尔值
boolean flag = true;
boolean flag = false;
4. 什么是字节
- 位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位二进制数
- 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示
- 1B（字节）=8bit（位）
- 字符：是指计算机中使用的字母、数字、字和符号
5. 数据类型扩展
//二进制0b
//十进制
int i = 10;
//八进制0
int i = 010;
//十六进制0x 0~9 A~F
int i = 0x10;
//浮点数扩展，银行业务怎么表示？
public class Demo01 {
public static void main(String[] args) {
//浮点数扩展 舍入差 离散 有限 接近但不等于
float num1 = 0.1F;
double num2 = 1.0 / 10;
double num3 = 7 / 2.0;
System.out.println(num2 + "," + num3);
System.out.println(num1 == num2); //false
float a = 332433455566F;
float b = a + 1;
System.out.println(a == b); //true
// BigDecimal 数学工具类
System.out.println("*********************************");
//字符扩展
char word1 = 'a';
char word2 = '中';
System.out.println((int) word1);
System.out.println((int) word2);
//所有字符本质上还是数字
//Unicode表 \u0000~\uFFFF
char word3 = '\u0065';
System.out.println(word3);
//转义字符
// \t制表符 \n换行符
System.out.println("Hello\tWorld");
System.out.println("Hello\nWorld");
//字符串扩展
String string1 = new String("hello world");
String string2 = new String("hello world");
System.out.println(string1 == string2); //false
String string3 = "hello";
String string4 = "hello";
System.out.println(string3 == string4); //true
//对象 从内存分析
//布尔值扩展
/*boolean flag=true;
if(flag==true){}
if (flag){}*/
}
}
6.char型详解
-
char初始化
- char c = ‘a’ //可以是汉字，因为是Unicode编码
- char c = 十进制数、八进制数、十六进制数 //可以用整数赋值
- char c = ‘\u数字’ //用字符的编码值来初始化
-
char a = 111 //整数，0~65535，输出字符编码表中对应的字符
-
char运算
- char m =‘a’;
- char m = ‘a’+‘b’ //char类型相加，提升为int类型，输出对应的字符
- char m = ‘197’; ——会报错。//因为有单引号，表示是字符，只允许放单个字符。
- char m = 197; //输出字符编码表中对应的字符
- char m = ‘a’ + 1; ——输出结果是b。//提升为int，计算结果98对应的字符是b
7.类型转换
byte,short,char–>int–>long–>float–>double
-
强制类型转换
(类型)变量名 高–>低
-
自动类型转换
低–>高
-
注意点
- 不能对布尔值进行转换
- 不能把对象类型转换为不相关的类型
- 把高容量转换到低容量的时候，强制类型转换，注意内存溢出问题或精度问题
public class Demo02 {
public static void main(String[] args) {
int a = 128;
byte b = (byte) a; //内存溢出
System.out.println(a+"**"+b);
System.out.println("**************************");
System.out.println((int)23.5);
System.out.println((int)-23.87);
System.out.println("***************************");
//操作比较大的数值时，注意溢出
//数字之间可以用下划线分开，如10_0000_0000
int money=10_0000_0000;
int year=30;
int total=year*money;
System.out.println(total);
long sum=year*money; //默认是int，转换之前已经存在问题
System.out.println(sum);
//正确用法
long sum1=((long)money)*year;
System.out.println(sum1);
}
}
8.变量
-
每个变量必须先声明其类型,可以是基本类型，也可以是引用类型
-
Java变量是程序中最基本的存储单元、其要素包括变量名、变量类型和作用域
-
type varName = [value][{,varName[=value]}]
-
变量名必须是合法的标识符
-
变量声明是一条完整的语句，因此每一个声明都必须以分号结尾
//程序可读性 int a,b,c; int a=1,b=2,c=3; //可读性不太好 int a=1; int b=2; int c=3; -
变量分类
- 类变量
- 实例变量
- 局部变量
public class Variable{
static int allClicks=0; //类变量
String str ="hello world"; //实例变量
public void method(){
int i = 0; //局部变量
}
}
9.常量
- 关键字final修饰
- 初始化后不能在改值
- 常量名一般用大写字符
- final 常量名 = 值;
10. 变量命名规范
-
所有变量、方法、类名要见名知意
-
类成员变量：首字母小写和驼峰规则（出第一个单词外，后面单词首字母大写）：monthSalary、lastName
-
局部变量：首字符小写和驼峰原则
-
常量：大写字母和下划线：MAX_VALUE
-
类名：首字符大写和驼峰原则
-
方法名：首字符小写和驼峰原则：run（）、runRun（）
public class Demo03 { //类变量，从属于类 static double wage = 3000; static int salary; //常量final static final double PI = 3.14; //实例变量，从属于对象，如果没有初始化，会赋予默认值 //int 0、浮点 0.0、char u0000、boolean false //引用类型默认null String name = "alen"; int age = 28; //main方法 public static void main(String[] args) { int a = 1; //局部变量，必须声明和初始化 System.out.println(a); System.out.println(wage); Demo03 demo03 = new Demo03(); System.out.println(demo03.name+","+demo03.age); System.out.println(salary); } //自定义add方法 public void add(){ } }
11.运算符
- 算术运算符：+、-、*、/、%、++、–
- 赋值运算符：=
- 关系运算符：>、<、>=、<=、==、!=、instanceof
- &&、||、！
- 条件运算符：？：
- 扩展赋值运算符：+=、-+、*=、/=
int a = 21233;
long b= 2324443L;
short c = 233;
byte d = 32;
System.out.println(a+b+c+d); //long类型
System.out.println(a+c+d); //int类型
System.out.println(c+d); //还是int类型
/* 如果有比int类型高的类型，那相加就是更高的类型，如果没有一律int类型
-
自增、自减
-
int a=1;
int b =a++; //先赋值给b，然后自增
int c =++a; //先自增，然后赋值给c
-
12.Math类
- 幂运算：Math.pow(2,3)=8
- 用法：Math.方法名();
13.包机制
- Java提供包机制，用于区别类名的命名空间
- 包语句语法：package pkg1[. pkg2]
- 一般利用公司域名倒置作为包名；如:www.baicu.com com.baidu.www依次建包
- 导包语法：import 包名
- import com.long.* //导入long包下所有类
- 导入某包下同名类，会报错！
- 建包com.long不分层解决方案
- 点击project右边的小齿轮（也有可能在右上方），并在弹出框选项中，取消勾选Compact Middle Packages选项即可
14.JavaDoc
-
javadoc命令用来生成自己的API文档
-
参数信息
- @author作者名
- @version版本号
- @since指明需要使用最早的jdk版本
- @param参数名
- @return返回值情况
- @throws异常抛出情况
-
生成doc文档命令：javadoc -encoding UTF-8 -charset UTF-8 Doc.java
-
IDEA生成doc文档
流程控制
1.Scanner对象
java.util.Scanner对象是Java5的新特征，可以通过Scanner类来获取用户输入
基本语法
Scanner s = new Scanner(System.in);
通过Scannner类的next()与nextLine()方法获取输入的字符串，在读取前需要使用hasNext()与hasNextLine()判断是否还有输入的数据
- next()与nextLine()的区别
- next()以空格为结束符
- nextLine()以回车Enter键为结束符，可以获取空格
public class Demo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a=0;
float b=0.0F;
System.out.println("请输入一个整数:");
if (scanner.hasNextInt()){
a=scanner.nextInt();
System.out.println("你输入的整数是："+a);
}else {
System.out.println("你输入的不是整数");
}
System.out.println("请输入一个小数:");
if (scanner.hasNextFloat()){
b=scanner.nextFloat();
System.out.println("你输入的小数是："+b);
}else {
System.out.println("你输入的不是小数");
}
scanner.close();
}
}
public class Demo04 {
public static void main(String[] args) {
//计算输入数值的和以及平均数
double sum =0;
int count=0;
Scanner scanner=new Scanner(System.in);
System.out.println("请输入数字：");
while (scanner.hasNextDouble()){
double x = scanner.nextDouble();
count++;
sum+=x;
System.out.println("当前第"+count+"个数"+",和为："+sum);
}
System.out.println("总合："+sum);
System.out.println("平均数："+(sum/count));
scanner.close();
}
}
2.顺序结构
程序按照从上到下的顺序依次执行
3.选择结构
-
If单分支结构
if(布尔表达式){布尔表达式为true时执行}
-
if双分支结构
if(布尔表达式){true时执行}else{false时执行}
-
if多分支结构
if(布尔表达式){}else if{}else{}
String s = "hello"
//判断字符串是否相等equals()
if(s.equals("hello")){
}
-
嵌套的if结构
if(布尔表达式1){
if(布尔表达式2){
}
}
-
switch多选择结构
switch(expression){ case value1 : //语句 break; //可选，但是不加的话，匹配成功后后续语句也会执行 case value2: //语句 break; //可以有任意数量的case语句 default: //可选 //语句 }
Switch语句中的变量类型可以是：
-
byte、short、int或者char
-
从Java7开始，switch开始支持字符串String类型了，但是case标签必须为字符串常量或字面量反编译：java—>class(字节码文件)—>反编译(IDEA)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1mP7tB38-1645361566995)(D:\Desktop\Java学习\img\反编译.png)]
- 将该文件夹下对应的class文件拷贝到java项目文件夹中
4.循环结构
1.While循环
while(布尔表达式){
//循环内容
}
2.do…while循环
- 至少执行一次
- 先执行后判断
do{
//代码语句
}while(布尔表达式)
3.For循环
for(初始化;布尔表达式;更新){
//代码语句
}
int a = 1; //初始化条件
while(a<100){ //条件判断
System.out.print(a); //循环体
a+=2; //迭代
}
for(int i =1;i<=100;i++){
System.out.print(i);
}
for(; ; ){
//死循环
}
4.增强For循环
for(声明语句:表达式){
//代码句子
}
- 声明语句：声明新的局部变量，该变量类型必须和数据元素类型匹配
- 表达式：表达式是要访问的数组名，或者是返回值为数组的方法
int[] numbers = {1,2,3,4,5};
for(int a:numbers){
System.out.println(a);
}
5.Break和Continue
- break用于强制退出循环
- continue用于终止本次循环
方法
1.何为方法
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或者对象中
- 方法在程序中被创建，在其他地方调用
- 设计方法的原则：保持方法原子性就是一个方法只完成1个功能
2.方法的定义
-
修饰符：可选
-
返回值类型：需与返回值类型一致、如果为空则为void
-
方法名：驼峰原则
-
参数类型：形参和实参(调用时)
-
方法体：方法体包含具体的语句
-
修饰符 返回值类型 方法名(形参){
//方法体
}
3.方法的重载
- 方法名必须相同
- 参数列表必须不同(个数不同、类型不同、参数排列顺序不同)
- 方法的返回类型可以相同也可以不同
- 仅仅返回类型不同不足以成为方法的重载
4.命令行传参
有时候希望运行一个程序时候再给它消息，这要靠传递命令行参数给main()
public class CommandLine{
public static void main(String args[]){
for(int i=0;i<args.length;i++){
System.out.println(args[i]);
}
}
}
- cmd 项目src目录
- 输入java com.jian.struct.Demo01 this is myFreeStyle
5.可变参数
- JDK1.5开始，Java支持传递同类型的可变参数给一个方法
- 在方法声明中，在指定参数类型后加一个省略号
- 一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通参数必须在它之前声明
public static void main(String[] args) {
ReMethodDemo reMethodDemo=new ReMethodDemo();
System.out.println(reMethodDemo.getMax(1,2,3,4,6));
System.out.println(reMethodDemo.getMax(new double[]{12,32,122,43}));
}
public double getMax(double... a){
if (a.length==0){
System.out.println("无效数组");
return 0;
}else {
double result=a[0];
for (int i=0;i<a.length;i++){
if (a[i]>result){
result=a[i];
}
}
return result;
}
}
6.递归
- 利用递归可以用简单的程序来解决一些复杂的问题，通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，大大减少了代码量
递归结构
- 递归头：什么时候不调用自身方法，如果没有头，将陷入死循环
- 递归体：什么时候需要调用自身方法
数组
1.数组概述
- 数组是相同数据类型数据的有序集合
2.数组声明创建
-
首先必须声明数组变量，才能在程序中使用数组
dataType[] arrayRefVar; //首选方法
dataType arrayRefVar[]; //效果相同，但不是首选方法
-
使用new关键字来创建数组，语法如下：
dataType[] arrayRefVar=new dataType[arraySize];
-
数组元素通过索引访问，数组索引从0开始
-
获取数组长度：arrays.length
-
数组未初始化时，会赋默认值
3.内存分析
-
堆:1. 存放new的对象和数组
2. 可以被所有的线程共享，不会存放别的对象引用 -
栈：1. 存放基本变量类型(会包含这个基本类型的具体数值)
2. 引用对象的变量(会存放这个引用在堆里面的具体地址)
4.数组三种初始化
-
静态初始化
int[] a = {1,2,3}; Man[] mans = {new Man(1,1),new Man(2,2)}; -
动态初始化
int[] a = new int[2]; a[0] = 1; a[1] = 2; -
数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也被按照实例变量同样的方式被隐式初始化了
4.数组四个基本特点
- 其长度是确定的，数组一旦被创建，它的大小就是不可以改变的
- 其元素必须是相同类型，不允许出现混合类型
- 数组的元素创建时，可以是基本类型，也可以是引用类型
- 数组变量属于引用类型，数组对象本身是在堆中的，无论保存原始类型还是其它对象类型
5.数组使用
-
For-Each循环
for(int array:arrays){ System.out.print(array); }public class ArrayDemo { public static void main(String[] args) { int[] arrays = {1, 2, 3, 4, 5}; printArray(arrays); System.out.println(); printArray(reverse(arrays)); } public static void printArray(int[] arrays) { for (int i = 0; i < arrays.length; i++) { System.out.print(arrays[i] + "\t"); } } public static int[] reverse(int[] arrays) { int[] results = new int[arrays.length]; for (int i = 0, j = arrays.length - 1; i < arrays.length; i++, j--) { results[i] = arrays[j]; } return results; } }
6.多维数组
-
二维数组
int[][] a = new int[2][5];
或者
int a[][] = new int[2][3];
又或者
int[][] a = {{1,2},{3,4},{5,6}};
7.Arrays类
- Arrays类中的方法都是static修饰的静态方法，在使用时候可以直接使用类名进行调用，而不用使用对象来调用
- 给数组赋值：通过fill方法
- 对数组排序：通过sort方法，按升序
- 比较数组：通过equals方法比较数组中的元素值是否相等
- 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找操作
8.冒泡排序
public class BubbleSort {
public static void main(String[] args) {
int[] arrays={21,24,33,34,23};
int[] result=bubbleSort(arrays);
System.out.println(Arrays.toString(result));
}
public static int[] bubbleSort(int[] arrays){
for (int i=0;i<arrays.length-1;i++){
boolean flag=true;
for (int j=arrays.length-1;j>i;j--){
if (arrays[j]<arrays[j-1]){
int temp=0;
temp=arrays[j-1];
arrays[j-1]=arrays[j];
arrays[j]=temp;
flag=false;
}
}
if (flag){
break;
}
}
return arrays;
}
}
9.稀疏数组
- 记录数组一共有几行几列，有多少哥不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
public class ArrayDemo {
public static void main(String[] args) {
//创建一个稀疏数组
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//打印稀疏数组
for (int[] a : array1) {
for (int b : a) {
System.out.print(b + "\t");
}
System.out.println();
}
//统计非0个数
int sum = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0) {
sum++;
}
}
}
System.out.println("******************************************");
System.out.println("非0个数是：" + sum);
//转换稀疏数组
int[][] array2 = new int[sum + 1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0) {
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
System.out.println("******************************************");
//输出稀疏数组
for (int[] a : array2) {
for (int b : a) {
System.out.print(b + "\t");
}
System.out.println();
}
//稀疏数组转回二维数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//重新输出
System.out.println("******************************************");
for (int[] a:array3){
for (int b:a){
System.out.print(b+"\t");
}
System.out.println();
}
}
}
面向对象
1.初识面向对象
- 分类思维模式
- 面向对象编程(OOP Object-Oriented Programming)
- 面向对象编程的本质：以类的方式组织代码，以对象的组织封装数据
- 抽象
- 三大特性：
- 封装
- 继承
- 多态
2.方法
- 静态方法-----static关键字
- 非静态方法
public void add(int a,int b){
System.out.println(a+b);
sub(2,3); //可以调用，随类存在
}
public static void sub(int a,int b){
System.out.println(a-b);
//add() 调用不了，创建对象才存在
}
3.值传递与引用传递
-
值传递
public static void main(String[] args) { int a=1; System.out.println(a); change(a); System.out.println(a); } public static void change(int a){ a=10; } -
引用传递
public class Demo02 { public static void main(String[] args) { int a=1; System.out.println(a); change(a); System.out.println(a); Person person=new Person(); person.name="海王"; System.out.println(person.name); change(person); System.out.println(person.name); } public static void change(int a){ a=10; } public static void change(Person person){ person.name="海龙"; } } class Person{ String name; }
4.类与对象的关系
- 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
- 对象是抽象概念的具体实例
- 使用new关键字创建对象
- 使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化以及对类构造器的调用
- 类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的，并且具有以下两个特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
- 有参构造器
- 无参构造器（默认有一个）
- 如果定义了有参构造器，就必须显示定义无参构造器
String name;
public Person(){
}
public Person(String name){
this.name=name;
}
5.封装
- 高内聚，低耦合。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用
- 封装：通常应该禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问
- 属性私有，get/set
public class InnerDemo {
public static void main(String[] args) {
Student student=new Student();
student.setId(1);
student.setName("海王");
student.setAge(22);
System.out.println(student.getId()+":"+student.getName()+","+student.getAge());
}
}
class Student {
private String name;
private int age;
private int id;
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 int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护性增加了
- 快捷键：Alt+Insert
6.继承
-
Java中只有单继承，没有多继承
-
关键字：extends
-
子类继承了父类，就会拥有父类的全部方法
-
在Java中，所有类默认直接或间接继承自Object类
-
子类和父类之间，从意义上讲应该具有"is a"的关系
-
快捷键：Ctrl+H查看继承树
7.super
- 私有的属性和方法无法继承
- 调用父类的构造器，必须要在子类构造器的第一行
- 默认先调用父类的无参构造
- super必须只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
- this()：本类的构造
- super()：父类的构造
- this：本身调用者这个对象，没有继承也可以使用
- super：代表父类对象，只能在继承条件中使用
public class SuperDemo {
public static void main(String[] args) {
Aminal aminal=new Dog();
}
}
class Aminal{
String name="旺财";
public Aminal(){
System.out.println("是个人");
}
}
class Dog extends Aminal{
public Dog(){
super();
System.out.println("是条狗");
print(super.name);
}
public void print(String name){
System.out.println(name);
}
}
8.重写方法
- @Override //重写
- 需要有继承关系，子类重写父类的方法
- 参数列表必须相同
- 修饰符，范围可以扩大但不能缩小
- 抛出的异常：范围可以被缩小，但不能扩大
9.多态
- 多态是方法的多态，属性没有多态
- 父类和子类有联系，类型转换异常：ClassCastException
- 存在条件：继承关系、方法需要重写、父类引用指向子类对象
不能重写：
- static方法属于类，他不属于实例
- final常量
- private方法
10.Instanceof/类型转换
- Person instanceof Student //返回true或false
强制转换
(子类) object = 父类引用
- 父类引用指向子类的对象
- 把子类转换为父类，向上转型：可能丢失子类本来的一些方法
- 把父类转换为子类，向下转型：强制转换
- 方便方法的调用，减少重复的代码
11.Static关键字
static{
//静态代码块
}
- static静态代码块只执行一次，且在构造方法前执行
- final修饰的类不能被继承
- import static java.lang.Math.random //静态导入包
12.抽象类
- abstract关键字
- 不能new抽象类，只能靠子类去实现它：约束
- 抽象类中可以写普通的方法
- 抽象方法必须在抽象类中
public class Behavior extends Action{
public Behavior(){
System.out.println("hi");
}
@Override
public void doSomething() {
System.out.println("run");
}
public static void main(String[] args) {
Action action=new Behavior();
action.doSomething();
}
}
public abstract class Action {
public Action(){
print();
}
public void print(){
System.out.println("Hello World");
}
public abstract void doSomething();
}
13.接口
- 声明接口的关键字是interface
- 接口定义默认public abstract
- 接口必须有一个实现类
- 接口可以多继承
- 接口只有定义无实现
- 接口定义常量默认public static final
作用：
- 约束
- 定义一些方法，让不同的人实现
- 接口不能被实例化，接口中没有构造方法
- implements可以实现多个接口
14.内部类
- 内部类就是在一个类的内部再定义一个类
public class Outer {
private int id=1;
public void print(){
System.out.println(id);
}
public class Inner{
public void print(){
System.out.println("Hello,World");
}
}
}
class Application{
public static void main(String[] args) {
Outer outer=new Outer();
//通过外部类来创建内部类的实例
Outer.Inner inner=outer.new Inner();
inner.print();
outer.print();
}
}
- 局部内部类
public class PartDemo {
public static void main(String[] args) {
method();
}
public static void method(){
System.out.println("Hello,World");
class Part{
public void print(){
System.out.println("海王");
}
}
new Part().print(); //匿名内部类
}
}
-
匿名内部类
public class AnonyDemo { static String name; public static void main(String[] args) { name="海龙"; new Animal().change(name); System.out.println(name); new Animal().setName("海王"); new Animal().printName(); } } class Animal{ static String name; public void setName(String name){ this.name=name; } public void printName(){ System.out.println(this.name); } public void change(String name){ name="海星"; } }
异常
1.什么是异常
- Exception
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5lLKkzei-1645702144228)(D:\Desktop\Java学习\img\异常.png)]
- Error和Exception的区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机(JVM)一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常
2.异常处理机制
- 抛出异常
- 捕获异常
try{
//try监控区域
}catch(ArithmeticException e){
//catch捕获异常
}finally{
//处理善后工作
}
- finally可选
- catch可写多个，但是最大的异常需要写在最后，从小到大
- Exception/Exception
- 快捷键：Ctrl+Alt+T
- System.exit(0)终止程序
throw
主动抛出异常，一般在方法体中使用
throws
抛出异常，方法上使用
3.自定义异常
用户自定义异常类，只需要继承Exception类即可
public class MyException extends Exception{
private int detail;
public MyException(int id){
this.detail=id;
}
//输出异常信息
@Override
public String toString() {
return "MyException{" +
"detail=" + detail +
'}';
}
}
public class TestException {
public static void main(String[] args) {
try {
test(2);
} catch (MyException e) {
System.out.println("Exception:"+e);
}
}
static void test(int a) throws MyException {
System.out.println(a);
if (a>1){
throw new MyException(a);
}
System.out.println("OK");
}
}
- 在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常
- 尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出
- 尽量添加finally语句块去释放占用的资源
