一.常用dos命令
在cmd窗口中输入
dir 查看当前路径下的内容
cd 目录 进入单级目录。cd wenjianjia
cd.. 回到上一级目录
cd 目录1\目录2\.. 进入多级目录
cd\ 回退到盘符目录
cls 清屏
exit 退出命令提示符窗口
D; 转到D盘
二.JAVASE
2.1注释
java程序中最基本的组成单位就是类，
类的定义格式：
public class 类名{
}
public class helloworld{
//这是main方法
//main方法是程序的入口方法，代码的执行是从main方法开始的
public static void main(String[] args){
//这是输出语句，“”里面的内容是可以改变的
System.out.println("helloworld");
}
}
//System.out.println("helloworld");输出内容换行
//System.out.print("helloworld");输出内容不换行
//System.out.println();换行
2.2关键字、常量
-
关键字全部小写
常量：
-
字符串常量
-
整数常量
-
小数常量
-
字符常量
-
布尔常量
-
空常量：一个特殊的值，null
2.3数据类型
基本数据类型
数值型：
整数（byte，short，int，long）
浮点数（float，double)
字符（char)
非数值型：
布尔型(boolean)
引用数据类型
类（class)
接口（interface)
数组([])
2.4变量
public class wada{
public static void main(String[] args){
int a = 10;
System.out.println(a);
}
}
//long w=1000000l
//long类型的变量定义时为了防止整数过大，后面要加L
//float v=13.14f
//float类型的变量定义时，为了防止类型不兼容，后面要加F
2.5标识符
-
由数字、字母下划线和美元符号$组成
-
不能以数字开头
-
不能是关键字
-
区分大小写
常见命名约定
小驼峰命名法（方法，变量）
-
约定1：标识符是一个单词的时候，首字母小写。如：name
-
约定2：标识符有多个单词组成的时候，第一个单词首字母小写，其他字母大写，如firstName
大驼峰命名法（类）
-
约定1：标识符是一个单词的时候，首字母大写，如Student
-
约定2：标识符由多个单词组成的时候，每个单词的首字母大写，如GoodStudent
2.6类型转换
自动类型转换
-
把一个表述数据范围小的数值或者变量赋值给另一个数据范围大的变量
数据范围从小到大-->
byte
short
char
int
long
float
double
强制类型转换
-
把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
-
格式：目标数据类型 变量名 = （目标数据类型）值或者变量；
-
范例：int k = (int)88.88;
-
2.7运算符
2.7.1算术运算符
当算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升，
等级顺序如图2-6
2.7.2自增自减运算符
++，--
当++在变量前面时先+后用，当++在变量后面时先用后+
2.7.3关系运算符
==，！=，>,<,<=,>=
2.7.4逻辑运算符
| & | 逻辑与 | |
|---|---|---|
| | | 逻辑或 | |
| ^ | 逻辑异或 | a^b,a和b结果相同为true，不同为false |
| ! | 逻辑非 |
2.7.5短路逻辑运算符
&&，||执行后会使后面程序短路
最常用的逻辑运算符为&&，||，！
2.7.6三元运算符
-
格式：关系表达式？表达式1：表达式2
-
范例：a>b？a：b
2.8数据输入
Scanner使用的基本
import java.until.Scanner;
public class ScannerDemo{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int x = sc.nextInt();
//这里只有x是变量名可以修改
System.out.println("x:"+x)
}
}
2.9流程控制
2.9.1顺序结构
2.9.2 if语句
-
格式1：
if(关系表达式){
语句体;
}
-
格式2：
if(关系表达式){
语句体1;}else{
语句体2;}
-
格式3：
if(关系表达式){
语句体1}else if(关系表达式2){
语句体2}else{
语句体3}
2.9.3switch语句
格式：
switch(表达式){
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
default:
语句体n+1;
break;
}
格式2：
switch(表达式){
case 值1：
case 值2：
case 值3：
语句体;
break;//值1，值2，值3都返回同一个语句体
default:
语句体n+1;
break;
}
2.9.4循环结构
格式：
for(初始化语句;条件判断语句;条件控制语句){
循环体语句;
}
2.9.5while 循环语句
while(条件判断语句){
循环体语句;
条件控制语句;
}
2.9.6do...while循环语句
do{
循环体语句;
条件控制语句;
}while(条件判断语句);
三种循环的区别for中变量执行完不可用，while执行完可用
2.9.7跳转控制语句
continue；跳过某次循环执行。直接进行下一次循环
break;结束当前循环
2.9.8循环嵌套
for(){
for(){
}
}
2.10 Random
①导包
import java.until.Random;
②创建对象
Random r= new Random();
③获取随机数
int number = r.nextInt(10);
//获取数据的范围:[0,10)包括0，不包括10
2.11 数组
2.11.1数组的定义格式
-
格式一：数据类型[] 变量名
-
范例：int[] arr
-
定义了一个int类型的数组，数组名为arr
-
格式二：数据类型 变量名[]
-
范例：int arr[]
-
定义了一个int类型的数组，数组名为arr
2.11.2数组初始化
1、动态初始化：初始化时只指定数组长度，由系统为数组分配初始值
-
格式：数据类型[] 变量名 = new 数据类型[数组长度];
-
范例：int[] arr = new int[3];
//new：为数组申请内存空间
2、静态初始化：初始化时每个数组元素的初始值，有系统决定数组长度
-
格式：数据类型[] 变量名 = new 数据类型[]{数据1，数据2，数据3}
-
范例： int[] arr = new int[]{1,2,3};
-
简化格式：数据类型[] 变量名 = {数据1，数据2，数据3};
-
范例： int[] arr = {1,2,3}；
获取数组元素数量
arr.length
2.12 方法
2.12.1 方法的定义与调用
方法：将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
带参数方法定义
-
格式：
public static void 方法名(数据类型 变量名1，数据类型 变量名2){
//方法体
}
//无参数()或者单个参数(数据类型 变量1)格式同理
方法调用
-
格式：方法名(数据类型 变量名1，数据类型 变量名2)
//需要在main方法中调用，main方法是程序的入口方法
//方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错
2.12.2 形参与实参
形参：方法定义中的参数，等同于变量的定义格式，例如：int number
实参：方法调用中的参数，等同于变量或常量，例如：10 或number
2.12.3 带返回值方法的定义与调用
-
格式：
public static 数据类型 方法名(参数){
return 数据;
}
//方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错，如boolean类型则返回true，int类型返回0；
2.12.4方法的注意事项：
-
方法定义之间不能嵌套
-
void 表示无返回值，可以省略return，也可以直接书写return，后面不加数据
-
调用方法时，void类型方法可以直接调用，非void类型方法，推荐用变量接受调用
2.12.5方法重载
方法重载：指同一个类中定义的多个方法之间的关系，
满足下列条件的多个方法相互构成重载
-
多个方法在同一个类中
-
多个方法具有相同的方法名
-
多个方法的参数不相同，类型不同或者数量不同
方法重载的特点
-
重载仅针对同一类中方法的名称与参数进行识别，与返回值无关
-
重载仅应对方法的定义，与方法的调用无关
方法重载的用途，可以使方法兼容全部的数据类型，如使sum方法可以兼容各种类型相加
2.12.6方法的参数传递
对于基本类型的参数，形式参数的改变，不影响实际参数的值
对于引用类型的参数，形式参数的改变，影响实际参数的值(如指针)
2.13类和对象
2.13.1类：
是现实生活中一类具有共同属性的行为的事物的抽象，确定对象将会拥有的属性和行为
类是java程序的基本组成单位
类的特点：
-
类是对象的数据类型
-
类是具有相同属性和行为的一组对象的集合
对象：是能够看得到摸得到的真实存在的实体
-
对象的属性：对象具有的各种特征，每个对象的属性都有特定的值
-
对象的行为：对象能够执行的操作
类的组成：属性和行为
-
属性：在类中通过成员变量来体现(类中方法外的变量)
2.13.2类的定义
public class 类名{
//成员变量
变量1的数据类型 变量1；
变量2的数据类型 变量2；
//成员方法
方法1；
方法2；
}
2.13.3对象的使用
创建对象
-
格式：类名 对象名 = new 类名();
-
范例：Phone p = new Phone();
使用对象
1：使用成员变量
格式：对象名.变量名
范例：p.brand
2：使用成员方法
格式：对象名.方法名()
范例：p.call()
2.13.4成员变量和局部变量
成员变量：类中方法外的变量
局部变量：方法中的变量
区别
| 区别 | 成员变量 | 局部变量 |
|---|---|---|
| 类中位置不同 | 类中方法外 | 方法内或者方法声明上 |
| 内存中位置不同 | 堆内存 | 栈内存 |
| 生命周期不同 | 随着对象的存在而存在，随着对象的消失而消失 | 随着方法的调用而存在，随着方法的调用完毕而消失 |
| 初始化值不同 | 有默认的初始化值 | 没有默认的初始化值，必须先定义，赋值，才能使用 |
2.13.5封装
private关键字
-
作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问
针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
-
提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
-
提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
this关键字
1.this修饰的变量用于指代成员变量
-
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
-
方法的形参没有成员变量同名，不带this修饰的变量是成员变量
this.name = name;
2.解决局部变量隐藏成员变量问题
3.this：代表所在类的对象引用
-
方法被哪个对象调用，this就代表哪个对象
封装的原则： 将累的某些信息都隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx/setXxx方法
封装的好处
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行控制，提高了代码的复用性
2.13.6 构造方法
构造方法是一种特殊的方法
作用：创建对象
格式：
public class 类名{
修饰符 类名(参数){
}
}
功能：主要是完成对象数据的初始化
//修饰符一般用public
2.14.7
API概述：应用程序编程接口
2.15string
字符串的特点：
-
字符串补课班，他的值在创建后不能改变
-
虽然String不能改变，但是它们可以被共享
-
字符串效果上相当于字符数组(char[]),但是底层原理的字节数组(byte[])
String构造方法
| 方法名 | 说明 |
|---|---|
| public String() | 创建一个空白字符串对象，不含有任何内容 |
| public String(char[] chs) | 根据字符数组的内容，来创建字符串对象 |
| public String(byte[] bys) | 根据字节数组的内容，来创建字符串对象 |
| String s="abc"; | 直接赋值的方式创建字符串对象，内容就是abc |
推荐使用直接赋值法
2.15.2字符串的比较
使用 ==比较
-
基本类型：比较的是数据值是否相同
-
引用类型：比较的是地址值是否相同
字符串的对象，可以用equals()方法进行比较
-
public boolean equals(Object anObject):将此字符串与制定对象进行比较。
直接比较字符串
字符串也可以被索引
char(0);
字符串的长度：字符串对象.length()
2.15.3 StringBuilder
String和StringBuilder的区别
String：内容不可变，需要常量池来储存
StringBuilder：内容可变
StringBuilder的构造方法： public StringBuilder() :创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str):根据字符串的内容，来创建可变字符串对象
StringBuilder的添加和反转
public StringBuilder append(任意类型)：添加数据，并返回对象本身
//因为返回对象本身，所以可以链式编程sb.append("").append("").append("")
public StringBuilder reverse():返回相反的字符序列
StringBuilder转换为String
public String toString():通过toString()就可以实现StringBuilder转换为String
publicStringBuilder(String s):通过构造方法就可以实现String转换为StringBuilder
2.16 集合ArrayList
-
集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变
ArratList<E>:
-
可调整大小的数组实现
-
<E>:是一种特殊的数据类型，泛型
构造方法：
public ArrayList():创建一个空的集合对象
添加方法：
public boolean add(E,e):将指定的元素追加到此集合的末尾
public void add(int index,E element):在此集合中的指定位置插入指定的元素
//如array.add(1,"abc")则在第二个位置插入“abc”（集合也是0,1,2开始
2.16.2ArrayList的集合常用方法
| 方法名 | 说明 |
|---|---|
| public boolean remove(Object o) | 删除指定的元素，返回删除是否成功 |
| public E remove(int index) | 删除索引处位置的元素，返回被删除的元素 |
| public E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |
| public E get(int index) | 返回指定索引处的元素 |
| public int size() | 返回集合中的元素的个数 |
3.1 继承
继承是面向对象的三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法
继承的格式
-
格式：public class 子类名 extends 父类名{}
-
范例：public class Zi extends Fu{}
-
Fu:是父类，也被称为基类、超类
-
Zi：是子类，也被称为派生类
继承中子类的特点：
-
子类可以有父类的内容
-
子类还可以有自己特有的内容
3.1.1继承的好处和弊端
好处
-
提高了代码的复用性（多个类相同的成员可以放到同一个类中）
-
提高了代码的维护性（如果方法的代码需要修改，修改一处即可）
继承的弊端
-
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时也不得不改变，削弱了子类的独立性
继承中变量的房屋特点
在子类方法中访问的一个变量
-
子类局部范围找
-
子类成员范围找
-
父类成员范围找
-
如果都没有就报错
3.1.2 super
super关键字的用法和this关键字的用法相似
-
this：代表对本类成员对象的引用
-
super：代表父类存储空间的标识（可以理解为父类对象的引用）
3.1.3继承中构造方法的访问特点
子类中所有构造方法都会默认访问父类中无参的构造方法
-
因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化
-
每一个子类构造方法的第一条语句默认都是：super()
3.1.4继承中方法重写
概念
-
子类中出现了和父类中一模一样的方法声明
方法重写的应用
-
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样即沿袭了父类的功能，又定义了子类特有的内容
注意事项
-
私有方法不能被重写（父类的私有成员子类是不能继承的）
-
子类方法访问权限不能更低（public>默认>私有）
3.1.5java中基础的注意事项
-
java中只支持单继承，不支持多继承
-
java中类支持多层基础
3.1.6修饰符
权限修饰符
| 修饰符 | 同一个类中 | 同一个包中子类无关系 | 不同包的子类 | 不同包的无关系 |
|---|---|---|---|---|
| private | √ | |||
| 默认 | √ | √ | ||
| protected | √ | √ | √ | |
| public | √ | √ | √ | √ |
状态修饰符
-
final(最终态)
-
static(静态)
3.1.7final
final关键字是最终的意思，可以修饰成员方法，成员变量，类
final修饰的特点
-
修饰方法：表明该方法是最终方法，不能被重写
-
修饰变量：表明该变量是常量，不能再次被赋值
-
修饰类：表明该类是最终类，不能被继承
final修饰局部变量
-
变量是基本类型：final修饰指的是基本类型的数据值不能发生改变
-
变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的
3.1.8static
static关键字是静态的意思，可以修饰成员方法，成员变量
static修饰的特点
-
被类的所有对象共享
这也是我们班队是否使用静态关键字的条件
-
可以通过类名调用
当然，可以通过对象名调用
推荐使用类名调用
static访问特点
非静态的成员方法
-
能访问静态的成员变量
-
能访问非静态的成员变量
-
能访问静态的成员方法
-
能访问非静态的成员方法
静态的成员方法
-
能访问静态的成员变量
-
能访问静态的成员方法
总结：静态成员方法只能访问静态成员
####
3、多态
3.1、前提和实现
-
有继承/实现关系
-
有方法重写
-
有父类引用指向子类对象：举例：Animal a = new Cat（）；
3.2、多态中成员访问特点
-
成员变量：编译看左边，执行看左边
-
成员方法：编译看左边，执行看右边
3.3、多态中的转型
3.3.1、向上转型
-
从子到父，父类引用指向子类对象（把子类对象赋值给父类引用：Animal a = new Cat（）；）
3.3.2、向下转型
-
从父到子，父类引用转为子类对象（Cat a = (Cat)a；）
4、抽象类
4.1、特点
-
抽象类和抽象方法必须用abstract关键字修饰
public abstract class 类名{}
public abstract void eat();
-
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
-
抽象类不能实例化（若要实例化，参照多态，通过子类对象实例化，这叫抽象多态）
-
抽象类的子类
要么重写抽象类中的所有抽象方法
要么是抽象类
5、接口
5.1、概述
接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。Java中的接口更多的体现在对行为的抽象
5.2、特点
-
接口用关键字interface修饰
public interface 接口名{}
-
类实现接口用implements表示
public class 类名 implements 接口名{}
-
接口不能实例化
若要实例化，参照多态的方式，通过实现类对象实例化，这叫接口多态。
多态的形式：具体类多态，抽象类多态，接口多态
多态的前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象
-
接口的实现类
要么重写接口中的所有抽象方法
要么是抽象类
5.3、成员特点
-
成员变量
只能是常量
默认修饰符：public static final
-
构造方法
接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在。
一个类如果没有父类，默认继承自Object类
-
成员方法
只能是抽象方法
默认修饰符：public abstract
5.4、类和接口的关系
-
类和类的关系
继承关系，只能单继承，但可以是多层继承
-
类和接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
-
接口和接口的关系
继承关系，可以单继承，也可以多继承
5.5、抽象类和接口的区别
-
成员区别
抽象类 变量，常量；有构造方法；有抽象方法，也有非抽象方法 接口 常量；抽象方法 -
关系区别
| 类与类 | 继承，单继承 |
|---|---|
| 类与接口 | 实现，可以单实现，也可以多实现 |
| 接口与接口 | 继承，单继承，多继承 |
-
设计理念区别
抽象类 对类抽象，包括行为，属性 接口 对行为抽象，主要是行为
6、内部类
6.1、概念
-
内部类：就是在一个类中定义一个类
-
格式：
public class 类名{}} -
访问特点
-
内部类可以直接访问外部类的成员，包括私有
-
外部类要访问内部类的成员，必须创建对象
-
6.2、成员内部类
①按照内部类在类中定义的位置不同，可以分为
-
在类的成员位置：成员内部类
-
成员内部类，外界创建对象使用的方法
-
格式1：
外部类名.内部类名 对象名 = 外部类对象.内部类对象（一般不常用） -
举例 Outer.Inner oi = new Outer().new Inner();
-
格式2：在外部类中实例化一个内部类对象 ，调用其方法，则在测试类中只需要创建外部类对象，调用该方法即可
-
-
-
在类的局部位置：局部内部类（在类的方法里面定义的类）
-
`public class Outer{` public int num=10; `public void method(){` `class Inner(){` `public void show(){` System.out.println(num); `}` `}` Inner i=new Inner(); i.show(); `}` `}` -
局部内部类是在方法中定义的类，所以外界无法直接使用，需要在方法内部创建对象并使用该类可以直接访问外部类的成员，也可以访问方法内的局部变量
-
-
匿名内部类（是局部内部类的一种特殊形式）
前提：存在一个类或者接口，这里的类可以是具体的类也可以是抽象类
-
格式：
new 类名或者接口名（）{ 重写方法； } -
本质：是一个继承了该类或者实现了该接口的子类匿名对象
-
重写方法输出：
new 类名或者接口名（）{ 重写方法； }.show()； -
若想调用两次，直接复制就行；若想多次调用，直接多次使用i.show(); 即可
类名或接口名 i= new 类名或者接口名（）{ 重写方法； } i.show(); -
匿名内部类在开发中的使用
-
7、异常
7.1、概述
异常：就是程序出现了不正常的情况
异常体系：Throwable包括Error和Exception
Exception包括RuntimeException和非RuntimeException
Error：严重问题，不需要处理
Exception：称为异常类，它表示程序本身可以处理的问题
-
RuntimeException：在编译期是不检查的，出现问题以后，需要我们回来修改代码
-
非RuntimeException：编译期就必须处理的，否则程序不能通过编译，就更不能正常运行了
7.2、JVM的默认处理方案
如果程序出现了问题，我们没有做任何处理，最终JVM会做默认的处理
-
把异常的名称，异常原因及异常出现的位置等信息输出在了控制台
-
程序停止运行
7.3、异常处理
如果程序出现了问题，我们需要自己来处理，有两种方案：
-
try ... catch ...
-
throws
①try ... catch ...
-
格式：
try { 可能出现异常的代码 }catch {异常类名 变量名} { //变量名其实是一个对象 异常的处理代码 } -
执行流程：
程序从try里面的代码开始执行
出现异常，会自动生成一个异常类对象，该异常对象将被提交给Java运行时系统
当Java运行时系统接收到异常对象时，会到catch中去找匹配的异常类，找到后进行异常的处理
执行完毕后，程序还可以继续往下执行
-
举例：
public class ExceptionDemo01{ public static void main(String[] args){ System.out.println("开始")； method(); System.out.println("结束"); } public static void method(){ try{ int[] arr={1,2,3}; System.out.println(arr[3]); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("你访问的数组的索引不存在")； } } }程序结果：
开始你访问的数组的索引不存在结束Throwable的成员方法：
方法名 说明 public String getMessage() 返回此throwable的详细消息字符串 public String toString() 返回此可抛出的简短描述 public void printStackTrace（） 把异常的错误信息输出在控制台 举例：
public class ExceptionDemo01{ public static void main(String[] args){ System.out.println("开始")； method(); System.out.println("结束"); } public static void method(){ try{ int[] arr={1,2,3}; System.out.println(arr[3]); }catch(ArrayIndexOutOfBoundsException e){ /*System.out.println(e.getMessage())；//返回出现异常的原因*/ /*System.out.println(e.toString());//输出影厂的类名和异常的原因*/ System.out.println(e.printStackTrace());//输出异常类名，异常原因以及位置信息 } } }
②throws
try ... catch ...无法处理一些可能出现的异常，针对这种情况，Java提供了throws的处理方案
格式：
throws 异常类名;
注意：这个格式是跟在方法的括号后面的
-
编译时异常必须要进行处理，两种处理方案，try ... catch ... 或者throws，如果采用throws这种方案，将来谁调用谁处理
-
运行时异常可以不用处理，出现问题后，需要我们回来修改代码
举例：
public class ExceptionDemo01{
public static void main(String[] args){
System.out.println("开始")；
method();
System.out.println("结束");
}
public static void method() throws ArrayIndexOutOfBoundsException{
int[] arr={1,2,3};
System.out.println(arr[3]);
}
}
7.4、编译时异常和运行时异常的区别
Java中的异常被分为两大类：编译时异常和运行时异常，也被称为受检异常和非受检异常
所有的RuntimeException类及其子类被称为运行时异常，其他的异常都是编译时异常
-
编译时异常：必须显示处理，否则程序就会发生错误，无法通过编译
-
运行时异常：无需显示处理，也可以和编译时异常一样处理
7.5、自定义异常
格式：
public class 异常类名 extends Exception{
无参构造;
带参构造;
}
举例：
public class ScoreException extends Exception{
public ScoreException() {}
public ScoreException(S tring message){
super(message);
}
}
public class Teacher{
public void checkScore(int score) throws ScoreExption{
if(score<0 || score>100){
// throw new ScoreException();
throw new ScoreException("你给的分数有误，分数应该在0-100之间");
} else{
System.out.println("分数正常")
}
}
}
public class TeacherTest{
public static void main(String[] args){
Scanner sc = new Scanner(Ststem in);
System.out.println("请输入分数：")
int score = sc.nextInt();
Teacher t = new Teacher();
try{
t.checkScore(score);
} catch (ScoreException e){
e.printStackTrace();
}
}
}
-
若抛出的throw是无参构造，则异常时不会输出错误原因
-
若抛出的throw是带参构造，则异常时的错误原因则会输出该参数内容
throws和throw的区别
| throws | throw |
|---|---|
| 用在方法声明后面，跟的是异常类名 | 用在方法体内，跟的是异常对象名 |
| 表示抛出异常，由该方法的调用者来处理 | 表示抛出异常，由方法体内的语句处理 |
| 表示出现异常的一种可能性，并不一定会发生这种异常 | 执行throw一定抛出了某种异常 |
8、泛型
8.1、概述和好处
定义格式：
-
<类型>：指定一种类型的格式。这里的类型可以看成是形参
-
<类型1,类型2...>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
-
将来具体调用的时候，给定的类型可以看成是实参，并且实参的类型只能是引用数据类型
举例：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*需求：Collection集合存储字符串并遍历*/
public class GeneriDemo{
public static void main(String[] args){
Collection<String> c = new Arraylist<String>();
c.add("hello");
c.add("world");
c.add("java");
Iterator it = c.iterator();
while(it.hasNext()){
// Object obj = it.next();
// System.out.println(obj);
String s = it.next();
System.out.prntln(s);
}
}
}
泛型的好处：
-
把运行时期的问题提前到了编译时期
-
避免了强制类型转换
8.2、泛型类
定义格式：
-
格式：修饰符 class 类名<类型>{ }
-
范例：public class Generic { }
此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
8.3、泛型方法
定义格式：
-
格式 修饰符<类型> 返回值类型 方法名（类型 变量）{}
-
范例：public void show(T t){ }
8.4、泛型接口
定义格式：
-
格式：修饰符 interface 接口名<类型>{ }
-
范例：public interface Generic { }
8.5、类型通配符
为了表示各种泛型List的父类，可以使用类型通配符
-
类型通配符：<?>
-
List<?>：表示元素类型未知的List，它的元素可以匹配任何类型
-
这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中
如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限
-
类型通配符上限：<?extends类型>
-
List <？extends Number>：它表示的类型是Number或者其子类型
除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限
-
类型通配符下限：<？super类型>
-
List<?super Number>：它表示的类型是Number或者其父类型
三.杂七杂八
crtl+alt+L为快速格式化代码
p101
1829
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
