第一章
将java文件编译成class文件:
在记事本中编辑java代码-----修改文件名为.java文件----打开cmd---进入文件所在文件路径如f:----在命令窗口执行
javac 文件名.java--执行命令：java 文件名
包名小写，类名首字母大写，类名可.java文件名要完全一致，是\n注意不是/
用javac 文件.java命令编译，后用java 类名 执行形成的Class文件
第二章
标识符的命名规则：(驼峰命名法)变量名，方法名第一个单词小写后面每一个单词首字母大写
三种注释：单行，多行《按住Shift鼠标点击开始结束部分，Ctrl+Shift+/》，文本注释
扫描类库:Scnner input=new Scanner(system.in);
取得输入的内容: answer= input.next();
Boolean flag= Input.hasNextInt();判断输入的值是不是整数,是就返回true,否则false
知道8种基本数据类型(byte,short,int ,long,float,double,char(a=97,A=65),boolean)存在栈中
引用数据类型：数组，类，接口（存在堆中）
Byteàshortàintàlong àfloatàdouble
char
Char可以自动转换为int类型 存储位数越多，类型的级别就越高
/*int age1=19;
char sex=‘女‘;
int result=age1+sex; //注意int和char类型相加自动转为高级的int类型，结果为int类型
System.out.println(result);*/
关系运算符的关系表达式结果为 布尔值
逻辑运算符与&，|，!
优先级：! > & > ^ > | > && >||(短路&&如果前面一个不成立后面的不参加运算)
Null值不能用equals方法判断等值;
三元表达式： 条件？表达式1 ：表达式2(条件为真执行表达式1,条件为假执行表达2)
Short s=1 ,s2=4; short s5=s+s2;两个short类型变量可以相加)（s=s+8;这时候报错）
String .equals比较的是值(不能为null)，==比较字符串的地址
第三章
1.Switch:(转换)
Switch(int mingci){ //快捷键 Alt+/+回车
Case 1 :System.out.print(“参加麻省理工一个月的夏令营”) break;
Case 2 :system.out.print(“送笔记本”) break; //跳出所在的循环
Continue //继续下一次循环
Default : 只有所有的case没有匹配上才执行default内容
}
Switch中的判断，jdk1.7一下不能为字符串,可以是int，enum,char(可自动转换为int)
While(条件){循环体} 当条件成立时执行，直道条件为false
注意：do...while(); 结束后面有分号
For(int i=0;i<10;i++){循环体;}
程序调试问题：
1.双击添加断点--à 2.按住小虫子或F12启动调试---à3.F6单步调试（F5单步跳入，跳入程序内部执行，如进入方法内部）
- java中的增强foreach循环（for score:scores）{system.out.print(score);}
for(int I : scores){system.out.print(i)}
for循环和foreach循环的区别：
- for循环需要知道循环的次数，foreach不需要知道循环的次数
- foreach用来遍历数组和集合使用更简单
- foreach循环语法格式更简单，无需下标，没有赋值语句，没有循环条件，没有迭代语句，这些操作有系统来操作
- foeach循环不要尝试去改变数组元素的值，因为数组元素赋给了一个临时变量
2.Return 语句的作用:
- 结束当前方法的执行并退出
- 返回调用该方法的语句出
第四章
1．数组在内存中是连续开辟空间的(数组中存放的元素可以是基本数据类型也可以是引用基本数据类型，必须是同一数据类型)
(1) int scores[]={1,2,3,4}; 或 int[] scores={1,2,3,4};
Int[] a={3,5} 定义数组时不指定长度，
(2) Int[] a=new int[]{1,2,3}; 初始化数组时，不指定长度
(3) Int[] a; a=new int[5]; a[1]={2};
数组是一个变量，存储相同数据类型的一组数据
数组的下标从0开始；
数组的编译错误和运行时异常；
2.二维数组的使用
二维数组的定义和初始化：
Int[][] scores=new int[5][5];
Int[][] scores={};
Int[][] scores=new int[][]{{1,2} ,{1,3},{3,4,4} };
Arrays类极其常用的方法：.equals(array1,array2);比较两个数组是否相等
.sort(array);数组的升序排列
.toString();array 将数组的Array转换成一个字符串
.fill(array,val);把 数组array的所有元素都赋值为val;
.copyOf(array,length);将数组array复制成一个长度为length的新数组
.binarySearch(array,val) 查询元素val在数组array中的下标
3.数组中的数据类型是必须“统一”自动转换为同一种数据类型
Int[] array={2,4,’a’}
第六章
1.面向对象
类和对象的关系：就是抽象和具体的关系
类名必须大写
成员变量有默认初始值；
OOA 面向对象分析 OOD面向对象分析
2.面向对象的优点：
1.与人类的思维习惯一致，
2.信息隐藏，提高的程序的可维护性和安全性
3.提高了程序的可重用性
类成员主要包括两部分：成员变量和成员方法
3.方法重载的优点：可以根据参数的不同，采用不同的实现方法，而且不需要编写多个名称，只要记住一个方法名即可
重载条件：方法名相同，参数列表不同(参数个数和参数类型不同，
参数的类型和个数相同，顺序不同)
4.成员变量和局部变量的区别：
- 作用域不同
- 初始值不同(对于成员变量如果在类定义中没有给它赋初值，Java会给她一个默认值，基本数据类型为0，引用数据类型为null，但是Java不会给局部变量赋值必须在定以后赋初值)
- 在同一个方法中，不允许有同名的局部变量
- 局部变量可以和成员变量同名，在使用中局部变量有更高的优先级
5.构造方法：如果自定义了一个或多个构造方法，那么java不会自动添加默认构造方法
1.构造方法必须和类名相同
2.没有任何的返回值类型
3.用来创建对象，初始化数据
6.This关键字的用法：
- 使用this调用成员变量，解决成员变量和局部变量的同名冲突
Person(int age){this.age=age}
- 使用this调用成员方法 this.work();
- 使用this调用重载的构造方法，只能在构造方法中使用，且必须是构造方法第一条语句
Public penguin(String name,String sex){this.name=name;this.sex=sex;}
Public penguin(String name,int health,int love,String sex)
{this(name,sex); this.health=health;this.love=love;}
This只能调用成员属性，实例方法，构造方法，不能调用类变量和类方法，也不能调用局部变量
this能不能调用类方法和类变量：
this可以调用类变量，但是类方法需要通过 类名.类方法 的形式调用。this是一个指向当前对象的指针，而对象是类的一个实例，所以this指向的是某个类的一个当前实例，而不是类本身
7.封装的作用：
- 避免外部操作引起的影响
- 提高松耦合和代码重用性
封装的概念：将属性私有化，提供公共方法来访问私有属性。
8.包的作用：
1.java 文件的组织形式
2.管理java文件
3.解决文件同名问题
4.也是一种访问控制机制
Java.lang包下面的所用工具不需要导入，可以直接引用
9.访问修饰符
|
修饰符 |
同一类中 |
同一包中 |
子类中 |
任何地方 |
|
Private |
Yes |
No |
No |
No |
|
无访问修饰符 |
Yes |
Yes |
No |
No |
|
Protected |
Yes |
Yes |
Yes |
No |
|
Public |
Yes |
Yes |
Yes |
Yes |
10.在类中声明成员变量：
成员变量可以是Class类型的成员变量
Public class Student{
Private Person person; //类中定义引用数据类型的成员变量
}
第七章
1.继承：使得一个类A能够直接使用另一个类B的属性和方法的途径
类A可以有自己的属性和方法
2.继承的语法：
修饰符 class 子类 extends 父类｛ //类定义部分｝
子类继承父类的什么：
- 继承public 和protected修饰的属性和方法，不管子类和父类是否在同一个包里。
- 继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里
子类不能继承：
- 无法继承private修饰的属性和方法
- 无法继承父类的构造方法
- 子类与父类不在同包使用默认访问修饰符修饰的(friendly)
如果从父类继承的方法不能满足子类的需求，在子类中可以对父类的同名方法进行重写。
- 方法的重写或方法的覆盖( overriding )
子类中根据需求对父类继承的方法进行重新编写
- 构成方法的重写的条件：
1.必须具有相同的方法名
2.必须具有相同的参数列表
3.返回值类型必须相同或者是其子类
4.不能缩小被重写方法的访问权限
重载(overloading)和重写(overriding)有什么区别：
重载涉及同一个类中的同名方法，要求方法名相同，参数列表不同，与返回值类型无关
重写涉及的是子类和父类之间的同名方法，要求方法名相同，参数列表相同，返回值类型相同或者是其子类
5.super关键字的使用：
Super代表当前对象的直接父类对象的默认引用
Super必须是出现在子类（子类的一般方法[super.方法名]和构造方法中）而不是其他位置。
Super 和 this 不能同时出现在一个构造方法中
Super指代父类：
- 调用父类成员：成员变量，成员方法，通过super.XXX
2.调用父类构造方法，通过super(),必须出现在构造方法的第一句话
用于访问父类的成员，例如父类的属性，方法，构造方法
访问权限的限制，例如无法通过super访问private成员。
- 继承条件下的构造方法的调用规则：
- 规则一：如果子类的构造方法中没有通过super显示调用父类有参的构造方法，也没有通过this显示调用自身其他构造方法，则系统会默认先调用父类的无参构造方法,在这种情况下，是否写 “ super(); “ 语句效果是一样的
- 规则二：如果子类的构造方法中通过super显示调用父类的有参构造方法，那将执行父类相应构造方法，而不执行父类无参构造方法
- 规则三：如果子类的构造方法中通过this显示调用自身的其他构造方法，在相应的构造方法中应用以上两条规则。
- 在继承条件下，代码的执行，先执行父类无参构造方法后调回子类，在一个类中，先加载父类属性，然后加载父类构造方法，然后子类属性，最后子类构造方法
构造方法不能循环嵌套调用
- Object的equals()方法
相等的属性值：两个对象具有相同的类型，相同的属性
同一个引用对象：两个引用指向同一个对象，即指向同一个地址
注意：如果单纯的使用object类的equals()方法来比较对象是否同一个引用对象，那么是跟操作符“==”没有区别
- 一个类构造方法在如下两种情况中总会执行：
- 创建该类的对象(实例化)
- 创建该类的子类的对象(子类的实例化)
|
访问修饰符 |
8.类图：—sex：String
- 多态
多态一词通常含义是指能够呈现出多种不同的形式或形态。他意味着一个特定类型的变量可以引用不同类型的对象，并且能自动地调用引用的对象的方法。
方法的重写是实现多态的基础。
10.子类转换为父类时的规则：
- 将一个父类的引用指向一个子类对象，称为向上转换，自动进行类型转换
- 此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法
- 此时通过父类引用变量无法调用子类特有的方法
11.向下转型的要求对接口和抽象（普通）父类同样使用
12.Instanceof 实现（boolean flag=pet instanceof Dog）
使用instanceof时，对象的类型必须和instanceof后面的参数所指定大类在继承上下级关系，否则会出现编译错误
13.多态的优势：
- 可替换性：多态对已存在的代码具有可替换行
- 可扩充性：多态对代码具有可扩充性，增加新的子类不影响已存在的类的多态性，继承性，以及其他特性的运行和操作，实际上新加子类更容易获得多态功能。
- 接口性：多态是父类向子类提供一个共同接口，由子类来完善或者覆盖来实现。
- 灵活性：多态在应用中体现了灵活多样的操纵，提高了使用效率
- 简化性：多态简化了对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。
14.final 修饰类、修饰方法、修饰属性
修饰类，不能再被继承
修饰方法，不能被子类重写
修饰的变量将变成常量，只能在初始化时 赋值 (单词每个字母大写)
15.static 的使用
修饰属性：调用用 类名 . 属性名
Static方法中不能使用非static属性;
修饰的静态代码块：
1.静态代码库比构造方法先执行，执行顺序是先加载父类中的静态代码块-后加载子类中的静态代码块，然后执行父类构造方法后执行子类中的构造方法
2.在类中的静态代码块无论创建多少个对象，只第一次创建时运行static代码快
3.当主函数中调用类中的静态方法也会先执行类中的静态代码库
4.在创建对象时候，会执行静态代码库
16.多态的使用：
1.父类指向子类对象
2.作为方法的形参
3.作为方法的返回值
18.return 返回多种不同类型的变量，多种不确定类型的可变参数的使用
1.可以定义返回一个Object[] 类型的参数
2.可以定义一个类，类中的属性定义为不同类型的属性，将不同类型的赋值给属性
public class Master {
public void feed(Pet pet){
if (pet instanceof Dog) {
System.out.println("*********8");
}
}
public void methad(int[] a){
}
public void methad1(int...is){
}
public void methad2(String s,int...is){
}
public void methad3(Object...objects){
}
public void methad4(Object[] a){
}
public Pet getPet(int money){
Pet pet=null;
if (money>10) {
pet=new Dog();
}else if (money>5) {
pet=new Penguin();
}
return pet;
}
第8章
1.抽象类
- 抽象类不能被实例化
- Abstract修饰符不能和final修饰符一起使用。
- Abstract修饰的抽象方法没有方法体
- Private关键字不能修饰抽象方法
- Abstract关键字必须在访问修饰符和返回值类型之间
- 一个类继承一个抽象类必须重写继承的所有抽象方法，除非它也是个抽象类
2.抽象类和接口
1. 区别：普通方法必须有方法体，抽象方法不能有方法体，抽象方法要有abstract修饰。
2.抽象 类不能创建对象，普通类可以创建对象
3.抽象类是一个不能被实例化的类，它可以具有抽象方法或普通方法
4.抽象类便于复用，接口便于代码维护
5.Public abstract class Person(){ 抽象方法，或者 普通方法}
3.接口：是一个不能实例化，且只能有抽象方法的类型
1.使用interface关键字接口中只能有抽象方法
2.Public interface Person(){ 抽象方法 }
3.接口中定义的变量默认是公共的 (public) 静态的 (static) 最终 ( final) 的常量（必须赋初始值）
4.接口中定义的方法默认是公有 (public ) 的抽象 (abstract) 方法
5.接口中方法必须有返回值类型
6.接口static 不能修饰接口中的方法
7.接口中不能用final 修饰方法
8.接口中不能有构造方法
9．接口可以继承多个接口，但是接口不能继承类
接口是针对行为而言的
多用组合少用继承
针对接口编程，不依赖具体实现
针对扩展开放，针对改变关闭
4.为什么接口中的方法不用abstract修饰呢，因为接口中只能有抽象方法不必用abstract修饰
规则：
- 抽象类与接口不能实例化
- 抽象类与接口分别被继承与实现的场合，其子类必须实现其中的抽象方法
- 抽象类中的抽象方法的访问修饰符不能为private，抽象类中的普通方法的访问修饰符可以为private,接口中的抽象方法的访问修饰符必须为public
5.implement 实现接口
1.实现接口必须实现接口里面的所有抽象方法
2.一个类同时继承一个父类，extends 在前，implements在后中间通过逗号，分开必须实现里面的所有方法
3.接口中的继承，用extends关键字，接口可以继承多个接口，被继承的多个接口间用逗号分开
6. 一个子类继承一个父类和实现多个接口时：
1. 调用父类中的字段和方法使用super.XXX
2调用接口中的字段和方法用：在子类中定义一个接口类型的成员变量，用接口类型的变量去点接口中的字段和方法
7.匿名内部类：
匿名内部类是指，父类是一个抽象类，在Test内的main方法中创建父类类型的对象，并在重写父类中所有抽象方法，
在父类中的写法 Cook cook=new Cook(){ 在这里重写父类中的抽象方法，也可以添加自己的方法，见BOOK1selfStudy-oop-Test3} ; 后面有分号
8.内部类见 BOOK1selfStudy-oop-Test2}
在内部类中调用外部类的属性用 外部类名Kitchen.this.XXXX的方法
抽象类中可以有构造方法，
第9章
1.异常的分类：
Object 为异常的根类，其次是Throwable为异常类的父类，分为
- Error是java虚拟机异常
- Exception异常类，异常类分为SQLExcepton和RunTimeException等
2.常见的异常：
1.ArithmeticException 计算异常
2.ArrayIndexOutOfBoundsException 数组越界异常
3.NullPointException 空指针异常
4.ClassNotFoundException没有找到相应的类文件（可能没有导入相应的jar包）
5.NumberFormatException 数据格式化异常（将不是数字转为数字格式的异常）
6.inputMismatchException 数组数据不匹配异常(用户输入的类型和数据中类型不匹配)
7.IllegalArgumentException 方法接收到非法参数
8.ClassCastException 对象强制类型转换出错
3.try {}catch(){ 要捕获的异常要和要发生的异常要 匹配}
4.try {} --catch (){}--finally{} 语句结构
1.如果try或catch 中有return语句，那么程序会先执行finally语句中的代码，执行完成或才执行return语句，如果finally中有ruturn语句就不会执行try { }catch{ }语句中的return了
2.在try—catch—finally语句结构中，try语句块是必须存在的，catch和finally语句块是可选的，但两者至少出现其中之一。
5.终止程序的退出使用，system.exit(0);正常退出
System.exit(-1);非零数字是非正常退出
6.java中异常处理是通过5个关键字来实现
try
catch 捕获异常
finally 无论是否发生异常，finally语句块中的代码总是执行，除非一种情况就是在异常处理代码快中执行System.exit(1)退出java虚拟机
throw
throws
Throws 声明方法可能要抛出的各种异常，
throw 手动抛出异常
e.printStackTrace();//打印堆栈异常信息
7.throw和throws的区别：
1.作用不同:throw用于程序员自行产生并抛出异常，throws用与声明该方法内抛出了异常
2.使用的位置不同，throw位于方法体内部，可以作为单独语句使用；thorws必须跟在方法参数列表的后面，不能单独使用。
3.内容不同，throw抛出一个异常对象，且只能是一个；throws后面跟一个异常类型，且可以跟多个异常类。
8.自定义异常: throw new 自定义异常类名(“异常原因”);