java开发目前主流的工具有eclipse，myeclipse，idea等，但是官方推荐的是eclipse，所以我们前期选择使用eclipse，后期采用idea。 网盘链接：https://pan.baidu.com/s/10kka1vjTbZV_IbCioIFrjg 复制这段内容后打开百度网盘手机App，操作更方便哦 提取码：biaw eclipse简介： ①eclipse解压安装即可用 ②eclipse的使用 概念： 工作空间（workspace）：里面可以存储多个项目 项目（project）：一个项目 eclipse界面简介： 上侧工具栏，中央是工作区，其他的选项卡即view（视图） 打开选项卡：window->showview->other->搜索选项卡->确认 选择视角：右侧open perspective（打开所有视角），选择需要的视角。 切换工作空间：file->switch workspace->other 输入工作空间 eclipse开发java项目： 1）新建java项目：file->new->other 选择所要创建的项目 2）java项目文件结构： ①jre：每一个项目中都必须有自己的jre ②src：资源文件夹，存放.java源文件 ③bin：用来存储编译后的文件（.class） 3）更改项目文件结构： 右键项目——>properties->java build path（java构建路径） 第一个选项卡：资源目录（src）和bin（二进制目录） 第三个选项卡：更改jre（jdk） 4）创建java源代码文件，编译运行： 编译：编写好.java文件就自动保存 运行：右键.java文件->run as->java application
概念： jdk是java（J2SE）开发环境，包含解析器、jre（java运行环境），以及其他工具。 安装： 1.获取jdk安装包，然后解压获得java主目录 解析包里主要文件有bin和jre： ①bin目录里面是存放二进制命令文件，其中主要文件有： java：可以用来测试版本 javac：将源码文件转化为电脑可识别的文件（.class） jar：将.class文件打包，便于运输和管理 ②jre目录：java运行时环境（包含jvm） 2.配置环境变量 未配置环境变量时： 注意：我这里是因为原来有一个版本的jdk，可以忽略。 右键计算机->属性->高级设置->环境变量->path（系统环境变量中的path）后追加java主目录/bin（path主要做用是快速访问） 配置完成： 3.测试 在一个文件夹下新建一个文本文档Test01，并输入代码，将文件后缀改为.java： 打开控制台，进入文件路径，然后输入javac Test01.java: 可以观察到源文件夹，多了一个Test01.class的文件，然后在控制台继续输入 java Test01： 输出hello，world！则成功调试。 注意：测试过程中，如果出现GBK字符不能转译，则将原来的文本文件另存为ANSI格式，然后再编译。
变量 概念：变量是可以不断改变的存储量。 变量与常量命名规范： 变量内容由数字，字母，下划线，$，中文等。 变量第一个内容不能以数字开头。 如： byte 1a//不合法 byte _ss//合法 变量名不能是关键字 如： int byte=10；//不合法 定义变量：（变量名存放在栈空间 stack）类型 名称；变量必须在申明后才能使用 使用变量： ①赋值（无限次赋值） 变量名=值（这个值存放在常量区） ②取值（根据变量名取值） int a=10； a=a+10； 数据类型 不同的数据类型分配不同大小栈空间 二进制：每一个0 1码，表示一个二进制位数 字节：八位二进制就是一个字节； 字符： 常见的基本数据类型有八种： 整数型（4种）： byte：1个字节（范围-128——127）-27——27-1 short：2个字节（-215——215-1） int：4个字节（-231——231-1） long：8字节（-263——263-1） 浮点型（2种）： float：单精度 4个字节 float 变量名=小数f（f表示单精度类型小数，如果不加则默认小数为doule类型）； 如：float a=1.5f； double：双精度 8个字节 boolean：值只有true或者false。如：Boolean b=15>10 值为true。 char：两个字节，值用单引号‘’；A—Z：65-90；a-z：97-122 例如：char ch=‘a’;int i=ch;System.out.println(i);//输出a=97 数字类型转换规则： 小转大，直接转：byte a=10；short b=a； 大转小，强制类型转化：int a=10；short b=（short）a；（直接赋值会报错，不能直接大专小） 运算过程中整数运算默认为int类型，小数默认为double类型。如果定义不同的类型，进行运算则选大类型。 常量（一次定义一次赋值） 语法：final 如：final byte b=28；b=12；会报错，不能进行再次赋值 输入（input）与输出（output） 概念： 程序接受的信息叫输入，程序显示的信息叫输出。 输出： System.out.println();//打印完后换一行 System.out.print()；//只打印不换行 System.err.println()；//红色打印 换行 转义符号：标志 \n 新起一行 \t 制表对齐 输入： 创建输入工具实例： Scanner input=new Scanner(System.in);//复杂的变量都是存放在堆中，需要new 接受输入信息： 类型 变量名=input.next类型(); 如： byte age=input.nextByte();//接收Byte
java运算符 单目运算符：++、- - 双目运算符：+、-、、/、%（目指操作数） %求余数 ++ - - a++:先用后加1 ++a：先加1后用 如：int a1=10;int b1=(a1++)+(++a1)+(a1++);结果为34. a- -：先用后减 - -a：先减后用 注意：如果++或者- -是单独一行，则直接执行自加或自减 赋值运算符 +=、-=、=、/=、%=：先运算后强转赋值 如：short ss=6; ss=ss+6//报错，因为没有强转，6是int类型。 ss+=5;//+=除了进行运算还能进行强转 逻辑运算符 语法：逻辑表示1 逻辑运算符 逻辑表达式2 &逻辑与：两个逻辑表达式都必须执行 |逻辑或：两个逻辑表达式都必须执行，只要有一个为真就为真 &&短路与：如果第一个表达式为false，则第二个不会执行 ||短路或：如果第一个表达式为true，则不会执行第二个 如：int ii=3; int nn=3; boolean b0=ii++>5&ii++<4;//两个表达式都执行 boolean bb1=nn++>2&&nn++<2;//如果第一个为false则不执行第二个 条件运算符 >=,<=,==,!= 取反：！逻辑表达式 如：boolean b=！（10>5） //结果为false 三元运算符 语法： 逻辑表达式？表达式1：表达式2 如：int ll=5; int cc1=10; int min=ll>cc1?ll:cc1;//求两个中哪个大用>,哪个小用<. 如果逻辑表达式为true则执行表达式1，反之执行表达式2。 运算符优先级 =优先级最高，（）优先级最高，单目高于双目高于三目
概念 根据多种条件选择不同分支 代码块：多行代码 if else 选择结构 语法：标准if else if(条件表达式1){ 满足条件1 } else if{ 不满足条件1且满足条件2 } else if（表达式n）{ … }else{ …都不满足 } 第一种改写：if（） 第二种改写：if，else if，…else 每个语句中只有一个语句 第三种改写：if（）esle（） 第四种该写：if() else if() switch case 选择结构 if else 条件判断，满足条件，执行分支的代码块 switch case 等值判断 switch(变量){ case 值1： case 值2： case 值3： default：（默认值，所有case不满足则进入case） } 小节： switch case，将变量的值和每一个case比较，如果相等就进入该case，如果不等就匹配下一个case 如果所有case都没匹配上，则进入default。 如果匹配到的case没有break，则执行该case下的所有case，包括default。 如果default不在代码最后且没有break，也会执行下一个case。 case的值必须是常量，类型是char，byte，short，int。jdk7后增加string，enum（枚举）。 循环 概念 循环：重复n次执行的操作，重复次数和重复操作 标准for循环： for（初始表达式；逻辑表达式；表达式3）{ } 初始表达式：所有循环开始前执行的代码，只执行一次 逻辑表达式：控制循环次数，每次循环前执行 表达式3：每次执行完该次循环后需要执行的代码。（即循环体内的表达式执行完） while循环 while（条件表达式）{//条件表达式控制次数 重复次数 } do while循环 语法： do{//不管条件成不成立，都要执行一次重复操作 }while（条件表达式）；//第n-1次执行前操作 如： int a=0; do { System.out.println(“第”+a+“次打印”); }while(a++<10);//执行次数是0到10. break与continue关键字 break：终止整个循环； continue：终止本次循环。//continue后的代码都不执行 如： int sum=0; for(int i=1;i<=100;i++) { if((i+1)%2==0) { continue; } sum+=i; } System.out.println(“偶数和为：”+sum); 嵌套循环 语法： for（）{//外层循环 for（）{ 内 } }
数组 概念 数组：一个可以定义多个同类数的类型，再内存（堆空间）中是连续的一段地址空间 定长、连续的一组数据（不可变）。 定义数组 语法： 第一种：类型[] 数组名 如：String name[]= {“tom”,“anna”,“lisa”}; 第二种：类型 数组名[] 如：int[] sorce= {11,22,33,44}; 初始化数组 第一种：只申请空间，每一个成员都是默认值 类型[] 数组名=new 类型[长度]; 样例： //申请了10个short长度的空间，每个成员为0 short[] ages=new short[10]; //每个成员的默认值为false boolean[] b=new boolean[3] //每个成员的默认值为null String[] s=new String[3] 第二种： 类型[] 数组名=new 类型[]{成员1，成员2…} 样例：long[] l=new long[] {1,2,3,4}; 第三种： 类型[] 数组名={成员1，成员2…} 样例：short[] s= {1,2,3,4}; 小节： 同一个数组变量，第二次初始化时不能使用第三种类型 样例： byte[] age=new byte[10]; age=new byte[20];//第二次初始化 age=new byte[] {1,2,3,4,5}; age= {1,3,5,6};//会报错。重新申请空间，必须初始化空间new 类型[] 使用数组 数组设置成员： 语法：数组名称[下标]=值； 获取数组成员（下标）： 数组名[下标] 循环操作数组： 标准for循环： byte[] age=new byte[10]; for(int i=0;i<age.length;i++) { byte a=age[i]; System.out.println(“第”+i+“个：”+a); } 增强for循环： for（类型 别名：数组名） 样例： for(byte b:age) {//可以即快速操作数组，但是无法看到下标 System.out.println(b); } 数组工具 jdk自带的用于操作数组的快捷工具 两个数组对比：Arrays.equals（数组a，数组b）。两个数组长度相同，并且每个下标对应的值相同，才是相同数组 样例： int[] a= {1,2,3,4,5}; int[] b= {1,2,4,3,5}; int[] c= {1,2,3,4,5}; int[] d= {1,2,3}; boolean flag=Arrays.equals(a,c); System.out.println(flag); 排序（升序）： Arrays.sort(数组名)； 样例： Arrays.sort(b); for(int i=0;i<b.length;i++) { System.out.println(b[i]); } 填充： Arrays.fill（数组名，初始值）：统一设置成某个值 样例： Arrays.fill(a, 9); for(int i=0;i<a.length;i++) { System.out.println(a[i]); } 数组复制： Arrays.copyof(数组，新数组长度) 样例： int[] b=Arrays.copyOf(a, 5); tostring：将数组的所有成员转化成字符串：[成员1，成员2…]。 Arrays.tostring(数组)； 样例：String a=Arrays.toString(a);//可以快速查看数组的成员 System.out.println(a)；//数组需要循环输出，转成字符串直接输出 binarysearch： Arrays.binarysearch(数组，被查找的数据)：查找对应数组的下标（采用二叉查找） 数据必须时升序排好 数组中有被查找的数据，返回对应的下标 样例： int[] a= {1,2,3,4,5,6,7}; int b=Arrays.binarySearch(a, 4); System.out.println(b);//输出结果为3 如果找不到：①返回为负数②找第一个比被查找大的数③下标从1开始 样例： int[] a= {1,2,3,5,6,7}; int b=Arrays.binarySearch(a, 4); System.out.println(b);//输出结果为-4。 //如果被查找的值比数组中最大的值都大，则返回最大的位置。（查找的理念为二叉树） 字符串 概念：有多个字符构成的一个值即为字符串。 字符串定义与初始化： 定义：String 变量名； 初始化或赋值： String a=“张三”; String a=new String(“张三”) 字符串操作： 只能进行+操作，任何类型和string相加都变成一个string 样例1：int a=5； string b=“a”+a//输出a5 样例2： String a=“Hello”+“world”; for(int i=0;i<a.length();i++) { System.out.print(a.charAt(i));//chart(下标)：获取对应字符串下标字符 } 二维数组 概念：一维数组的每一个成员也是一个一维数组，该数组为二维数组 定二维数组： 第一种：类型[][] 数组名; 第二种：类型 数组名[][]; 初始化二维数组： 第一种：指定了一维数组、二维数据统一的长度 类型[][] 数组名=new 类型[一维长度][二维长度] 第二种：只指定以为数组的长度 类型[][] 数组名=new 类型[一维长度][]
概念 类：（抽象）具有相同特征数据的集合，或者相同特征对象的抽象叫做类，如生产的模具 如：人类，猫类，汽车类，飞机类等等 对象：（具体的）类的一个实例即为一个对象。 如：张三，白猫，别克川aXXXX(用数据具体描述出来) 类的构成：类名，属性（静态特征），方法（动作行为） 如： 学生类{ //属性 学号，性别，年龄，所在班级 所在年级 //方法 考试（） 上课（） } 定义类的步骤 类的构成： class 类名{ //成员变量1（属性，即具体对象的属性） //成员变量2 //成员方法（具体对象的行为） //局部变量（只作用于当前代码块，调用一次执行一次，不能前面加static） //成员代码块 //静态方法（所有成员都有的，一模一样的行为；在类创建的时候静态方法就加载） //静态变量（成员变量前加上static修饰词；不能放在代码块中） //静态代码块 //构造方法（） } 样例： class 鞋{ 尺码 颜色 价格 品牌 穿（） 走路（） } 定义类步骤： 定义类名（发现类） 定义类的属性（大部分都是成员变量） 定义类的方法 创建类的一个对象（实例）： 定义一个对象： 类型 对象； 初始化一个对象： 对象=new 类型 方法 概念：可以重复调用（通过名称）的代码块{} //用什么类型的类型名取决与你要返回的是什么类型的数值 语法： 修饰符 [static] void 方法名（参数列表）{ 方法体 } 方法名：调用的唯一关键字，只能通过方法名调用 参数列表：为方法体服务，调用该方法时必须全部满足（参数列表中的即为局部变量） 方法体：重复调用的代码块 返回值： 最后一行逻辑代码；该行代码后无可执行代码 如果方法体中没有return，表示没有返回值，则类型必须为void（注意：构造函数没有返回值） 方法的返回值在方法体执行完之后返回给调用者（return返回的数据，不能直接读取，需要先设置一个接收数据） 方法体中return的类型必须和方法规格（类型名）中的返回值类型一致 样例： Person类 int laught(String age,String gender) {//定义一个方法；参数列表可以多个，用逗号隔开 System.out.println(age+gender+name+“在哈哈大笑”+(++count)+“次”);//成员方法可以调用成员变量 return count;//无返回值用void，有返回值用int Person调用 p1.laught(“24岁”,“男”);//对象调用成员方法;如果调用的成员方法有参数列表，则在调用的时候把参数列表的值填充 p1.laught(“24岁”,“男”); int cnt=p1.laught(“24岁”,“男”);//这里使用的调用者（p1.laught(“24岁”,“男”)）相当于count void没有返回值 参数列表和成员变量的区别： 成员变量一般是一个对象里不易改变的的信息，如姓名，年龄等。 参数列表一般是一个对象里需要改变的，如乘坐的交通工具 简写： void 方法名（）{//{}方法体 可重复调用的代码块 } 在java中常见的三种方法：成员方法（要有对象才能实现），类方法，构造方法 成员方法：必须通过对象调用，该方法属于成员 调用：对象.方法（参数列表） 类方法（静态方法）： 该方法归属于类，可以通类名或对象名同时调用，方法前必须有stati关键字。类方法不能调用成员变量。 调用： 类名.方法（参数列表） 或 对象.方法（参数列表） 构造方法：（主要针对成员变量） 语法： 修饰符 类名（参数列表）{方法体} 注:方法名是类名，没有返回值 构造方法的作用:创建一个对象(主要是初始化成员变量) new 构造方法名（参数列表）；//构造方法即为类名 对象必须都是new出来的（通过构造方法），每一个类至少有一个构造方法，如果类（class）中 没有自定义构造方法，程序就会默认增加一个无参的构造方法。 例如： class Person{ Person（）{} } 构造方法通过new构造方法直接调用 样例： 类： Person(){ System.out.println("***************"); } 调用： Person p1=new Person()//运行可直接输出：*************** 变量 成员变量：对象的变量（成员变量也可以不给值，默认有初始值） 静态变量： 语法：变量前static关键字，只能在成员变量前加关键字，可以通过类名直接访问 静态变量可以不给初始值，有默认值 使用方法： 类名.静态变量 对象.静态变量 局部变量：在代码块中定义的变量（{}） 语法：和成员变量相同（但是不能加static） 使用方式： 使用前必须初始化赋值，不给值会报错 局部变量有生命周期（有效期），有效期的范围是代码块里面 局部变量名称可以和成员变量名称相同，优先使用局部变量的值 样例： String name=“张三” System.out.println(name);//访问局部变量 System.out.println(this.name);//访问成员变量
this关键字（当前对象） this.成员变量 this.成员方法 样例： public void dog() { //访问成员变量（如果没有与局部变量同名可以省略this） System.out.println(this.gender+name); //访问成员方法 this.speak();（speak的方法：public void speak()） //访问静态方法(成员方法可以访问静态，静态不可以访问成员) this.cat();（cat的方法：public static void cat()） } this()：调用本对象的构造方法，只能出现在构造方法中，调用另一个构造方法，且必须加在第一行 第一种：this（）->无参的构造方法 样例： public Person(String name) {//带参构造方法 this();//this（）只用于构造方法中，调用另一个（重载）构造方法 } 第二种：this(name)->带参的构造方法 样例： public Person(String name,String gender) { this(name);//调用带参的构造方法 this.gender=gender; } 构造方法
修饰符 概念：限制访问范围，即作用域 修饰符出现的位置： ①类：修饰符 class 类 ②成员变量：修饰符 类型 成员变量 ③成员方法（类方法）：修饰符 [static] 返回值 方法名（参数列表） ④构造方法：修饰符 类名（参数列表） 修饰符的值： private（私有）<default（默认）<protected(保护)<public(公有)//没有修饰符默认为default private（私有）:在同一个类中可以使用 default（默认）:在同一个包中可以使用 protected：在子类中可以使用 public：其他地方 包（package） 包是一种文件管理规范，类似于d盘下面的文件夹 包：域名（一级包名）.项目名.分类 如：cn.sina.bbs.utils//新浪的bbs项目下的工具包 使用包：不同包之间相互引用，需要在class上引用 只有两个文件相互作用，且都在一个包下才不需要import 代码块 成员代码块 语法：{} 只执行一次，创建对象时最后执行 静态代码块//初始化数据的作用，不能直接调用 语法：static{} 创建类的时候最后执行 方法扩展知识 方法参数使用 传值：值拷贝 当方法的参数为8大基本类型或者string类型时，方法中的形参都是一个原值的拷贝 示例： 类中： double PI=3.14; public void cycle(double r) } double s=PIrr; System.out.println(s); } 程序中： int a=10; p1.cycle(a);//将a的值拷贝给r System.out.println(a);//输出还是10 传址：址传递 当参数为复杂类型，（除8+string类型外） 方法重载（overload） 概念：同一个类中，方法名相同的多个方法，必须符合重载的要求 简化了类调用方法的代码 条件： 同一个文件（同一个类） 方法名相同 参数列表不同（参数相同是参数列表能一一对应，有一个不能对应就不是相同） 和修饰符和返回类型无关 样例： //重载 public void max(int a,int b) { System.out.println(a>b?a:b); } //重载参数列表 public void max(double a,double b) { System.out.println(a>b?a:b); }
继承 概念 B类可以继承A类的信息，B类信息=A类信息+B类独有信息 两个类，一个类可以通过extends关键字获取另一个类的属性和方法（受修饰符限制），这种关系即是继承 继承步骤： 定义父类（被继承的即为父类），父类中主要是公共属性和公共方法 定义子类（继承父类的类），子类中有自己独有的属性和方法 通过extends实现继承关系，子类只能继承一个父类（不支持多继承） 继承要点： 子类中能够访问父类中protected、public属性和方法 子类不继承父类的构造方法（和构造方法的修饰符无关），但是可以通过super关键字调用 子类独有的方法，如果和父类的方法名相同，且参数列表相同叫重写 子类对象可以通过super关键字来访问父类对象的信息 继承实现（extends)（父类私有的成员变量和成员方法不能继承；子类的继承权限来自父类的修饰词） 当对象调用继承中的方法时，先创建父类对象再创建子类对象 样例： public mankind() { System.out.println(“正在创建父类对象”); } public student() { System.out.println(“正在创建子类对象”); } new student();//输出"正在创建父类对象"“正在创建子类对象” 人员类（mankind）： public class mankind { private String name; private String gender; private String birthday;} 学生类(student)： public class student extends mankind { private String stuID; private String classID;} 教师类(teacher)： public class teacher extends mankind{ private String job; private String tno; } super关键字（调用父类的成员变量或成员方法） super.父类对象成员变量 this.父类对象成员变量（先找当前类有此成员变量没有，有就指向当前类，没有就指向父类） super.父类对象成员方法 super（参数列表）//父类构造方法 子类中构造方法第一行代码必须是调用父类的构造方法语句，如果没有则默认增加super（） 子类的所有构造方法都可以调用父类的构造方法，但是受修饰符的限制 object类 概念 object是所有复杂类型（不包括8大基本类型）的最高父类 class A（） //A的父类即object object的方法 tostring（）方法：复杂类型一般都不相等，除非两个是s1=s2 返回对象信息，以字符串的方式，默认格式，全限定名@hashcode码 Student s1=new Student（）； String Str=s1.toString（）； System.out.println(s1);//会默认调用toString的方法，与System.out.println(Str) 输出结果一致：cn.kgc.Class.Create.student@1b6d3586 equals（）方法： 如果用对比，比较的是地址；equals（）比较的是内容 如果不重写还是，所以一般都要重写，复杂类型的对比，如果用==，则比较的是tostring hashcode（）方法：哈希码：访问的是对象的地址 默认：等同于对象的内存地址 小节： 如果没有重写复杂类型的tostring，则调用object的tostring全限定@hashcode码 如果两个对象==来判断，实际上调用tostring（）sostring（） ab//a.toString（）==b.toString（）理论上是不可能永远相等，除非a，d是一个对象 复杂类型需要用equals比较，但也需要重写，不重写也是全等 注意：直接定义的字符串string，如果调用equals则直接调用object类的，比内容 和类中的用法不一样，需要注意。 继承中的特殊知识点 构造方法 参考super的三种使用 方法的重写（overridding）：重写之后对象只有子类方法，父类方法被覆盖 父子类中，子类的方法可能存在重写 子类与父类方法名相同 参数列表必须相同 返回值类型相同 修饰符的范围不能小于父类修饰符的范围
修饰符 同类 同包 同子类 其他 private(私有) √ × × × default（默认） √ √ × × protected（受保护） √ √ √ × public（共有） √ √ √ √ 多态 概念（多态使用的基础是继承） 同一个数据多种状态展现方式 结论： 子类可以看成父类类型，语法以父类为主，实际上是调用的子类方法（所以会受到修饰符的限制） 转型 同一个数据多种状态之间的转换 向上转型：子类转父类，自动转型 向下转型：父类转子类，强转 如： student s1=new student() uers u=new uers() uers u1=new student()//向上转型 student stu1=(student)u1//向下转型 student stu2=(student)u//类型转换错误，向下转的前提是要有向上转 多态的应用 方法 参数的多态 方法 返回值的多态 方法的返回值的类型是父类 public static User Create(int num){//user为父类，teacher和student为子类 if(num==1){ return new teacher();//返回值，自动转化为父类型 }else{ return new student();//返回值，自动转化为父类型 } } instanceof 判断 作用：判断一个对象是不是符合某一个类（对象是不是属于这个类，子对象属于父类），返回值是boolean类型 student s=new student boole a= s instanceof student//返回true final 关键字 概念 final：最终，不可改变 final在类上使用：最终类不可被继承 final在变量上使用：该变量不可再被改变，final类型的常量必须给初始值 final在方法上使用：该方法不可被重写 小节：父类出现final方法（不管static还是成员）子类都不能出现重写方法。
抽象类 概念：是一个不需要创建实例（抽象）的类，同时该类中存在一些方法，所有子类都会完全重写 抽象类特点 class 有abstract关键字，该类无法被实例化 结构上多了抽象方法（相对于普通结构），抽象方法没有方法体 抽象类被继承后结论： 抽象类中可以有普通方法，但是抽象方法不能有方法体 抽象类被抽象类继承，抽象方法可以被重写也可以不重写 抽象类被普通方法继承，则必须重写，否则会报错 抽象类结构 修饰符 abstract class 类名{ 构造方法 成员变量 成员方法 成员代码块 静态变量 静态方法 静态代码块 抽象方法//抽象类独有 } 抽象方法： 概念：没有方法体的方法。只有抽象类和接口才有抽象方法 语法： abstract 返回类型 方法名（） 样例：public abstract void print(); 接口 概念 接口：即一种标准或者一种规定 定义接口 //接口里没有构造方法 修饰符 interface 接口名{ public static final 类型 变量名//静态常量（即便没有写public、static、final还是默认会有） public abstract 返回类型 方法名（参数列表）；//抽象方法 public static 返回类型 方法名（参数列表）//静态方法 接口继承 子接口可以继承父接口 可以继承多个父接口 public interface Use3 extends Usb2,Usb1 接口实现(类实现接口 implements) 类实现接口，用implements关键字，可以实现多个接口 普通类实现父接口，必须重写父接口中的抽象方法 抽象子类实现父接口，可以不重写父接口中的抽象方法 面向接口编程（iop） 多定义接口，选择抽象类和接口类作为父，优先接口，组合 使用具有接口特征的子类对象时，建议使用接口类型 形参udisk类型，建议写成接口类型 public void print(Usb usb) {//解耦设计，面向对象编程 usb.usbIn();//调用插入的方法 usb.usbOut();//调用退出的方法 } public void print(udisk u) {//耦合设计 usb.usbIn();//调用插入的方法 usb.usbOut();//调用退出的方法 } 抽象类与接口的区别 接口区别： 抽象类使用abstract关键字，接口用interface关键字 使用区别： 抽象类中的抽象方法没有方法体，子类继承抽象类必须重写抽象方法 接口在使用的时候要使用关键字implements，同时接口可以多继承 接口中成员变量是默认为static和finally 成员方法只有静态和抽象 其他知识 时间 语法：System.currentTimeMillis() 返回的是：long 类型，单位毫秒，值1970-1-1之间的时间差 样例： long starttime=System.currentTimeMillis();//记录开始时间 System.out.println(“输入一句话显示你用的时间：”); String Speak=input.next(); long endtime=System.currentTimeMillis();//记录结束时间，单位是毫秒 int i=(int)(endtime-starttime)/1000;//记录结束时间 System.out.println(“你用的时间是：”+i+“秒”); 随机整数（0-n） 类:java.unit.Random; 语法：随即对象.nextXXX（极限值） 样例： 创建工具对象 利用工具对象的nextXXX(n) 方法随机0-n随机整数 Random ran=new Random();//创建一个随机对象 for(int i=0;i<10;i++) { int b=ran.nextInt(9);//给随机数的范围为9 System.out.println(b); } 字符串（线程安全 StringBuffer） 创建字符缓冲对象 StringBuffer 增加内容 append（“内容”） 获取字符串的方法是toString StringBuffer sb=new StringBuffer(">");//创建一个字符缓冲对象，并给初值< sb.append(">"); sb.append(">"); sb.append(">"); String s=sb.toString();//用tostring接收字符串 System.out.println(sb);//输出字符串>>>> 关闭jvm虚拟机（程序强制退出） 语法：System.exit(数字状态码) 0：表示正常结束 其他数字：表示非正常结束 for(int i=0;i<10;i++) { if(i>5) { System.exit(1);//程序退出，关闭虚拟机 } System.out.println(i);//打印i } System.out.println(“谢谢使用”);//这行代码不会执行
概念：引起程序非正常结束的原因 如：常见的除数样例 int a=10; int b=0; int c; c=a/b; System.out.println©; java的异常处理主要有两大类： error：非jvm引起并处理的异常，如设备断电导致的异常 exception：jvm能够自己处理的异常，主要由异常对象来完成 java的异常处理：catch，try，finally，throws，throw java异常机制：不破坏原有结构继承上 异常常用术语 try块：可疑代码块，可能产生异常的代码块 try块主要放的是可能产生异常的代码块，如果产生异常，我们才能在后续处理（如catch） 如果程序处理了，就会继续执行 try知识点： try不能单独存在，要和其他关键字（catch、finally）一起使用 try块中出现return关键字，那么程序可能提前结束（没有异常） catch：捕获 catch处理相邻try块中的异常 catch知识点： 必须和try块配套使用 一个try块可以匹配多个catch块 多个catch块，如果有父子关系，子异常在前，父异常在后 如果出现了return关键字，catch块所在方法直接结束 如果catch块中出现System.exit(0),jvm直接关闭 finally（最终代码块） finally块：只要是try块产生异常，不管catch有没有捕获到异常，finally块都会最终执行一次 finally不能处理异常（catch可以处理异常） finally不能单独使用 在try或catch中出现return关键字，finally不受影响（但是同方法中后续代码不会继续执行） 在try或catch中没出现return关键字，finally不受影响（但是同方法中后续代码会继续执行） 在try或catch中出现System.exit（0）时，finally才不会执行 注意执行顺序：try->catch->finally->return throws（抛出异常）：有抛出异常等待处理 位置：出现在方法上，参数列表之后 作用：严格要求参数调用者处理异常 如：public static void test() throws Exception throw：人为手动抛出一个异常 throw new 异常类型（异常详细信息） throw和throws配套使用 public void setage(bety age) throws Exception{//将这个异常抛给上一级处理 if(age<0){ throw new Exception(“年龄小于0)；//人为手动抛出一个异常 }else{ this.age=age } } 组合： try{ } catch（InputMismatchException i）{} catch（ArithmeticException a）{}//catch可以有多个，可以让不同的异常进入不同的代码块 try中发现异常的行数之后，会直接执行catch代码块。异常之后的代码块不会执行，而且try之外的异常不能捕获 InputMismatchException：输入类型不匹配 ArithmeticException：算术异常 异常对象 常见的异常对象->RuntimeException->Exception->Throwable Throwable提供两个方法 getMessage()：String->返回的是异常详细信息 a.printStackTrace()：红色打印异常对象所有信息 常见异常： RuntimeException：运行时异常，是Exception的子类 ArithmeticException：算出异常，如除数为0 InputMismatchException：输入类型不匹配 java.lang.NullPointerException：空指针异常（空地址） String str=null; System.out.println(str.length()); java.lang.ArrayIndexOutOfBoundsException：数组下标越界异常 java.lang.ClassCastException：类型转换错误
