日常学习笔记

9.2
①
自定义标识符：包，类/接口，变量/常量，方法（函数），参数
注意规则：
1.包：全部小写。
2.类和接口：如果是一个单词，首字母大写，其他小写；
如果是多个单词，每个单词的首字母大写，其他小写（驼峰原则）。
3.变量：一个单词，小写；
多个单词，从第二个单词开始首字母大写。
4.常量：全部大写。
5.方法：一个单词，小写；
多个单词，从第二个单词开始首字母大写。
6.参数就是变量。一个单词，小写；
多个单词，从第二个单词开始首字母大写。
命名规则：
1.所有的标识符由字母、数字、_、$组成。
2.不能以数字开头。
3.长度不受限制。
4.见名思义。
5.不能用Java关键字。
②
基本数据类型：

整数型：byte（1字节，8位 2^8 -128~127）
短整型：short（2字节，16位）
整型：int（4字节 32位 2^32）
长整型：long（8字节 64位）
浮点型：float（4字节 32bit 最多7个小数）
double（8字节 64bit 最多15个小数）
字符型：单引号引起来的单字符（2字节 16bit）
布尔型：true，false
类，接口，数组
变量的定义：在程序执行过程中有可能发生改变。
类型+标识符=常量 //初始化
先声明，后赋值 int age age = 21
注意：
变量必须——先赋值，后使用
常量：在程序运行过程中不发生改变的。
整数常量：3 7
小数常量：3.14
字符常量：“a”
布尔常量：true，false
十进制
二进制（1，0）
八进制
十六进制
十转二（连续除二，直到商为零为止，把余数倒序写）：9——1001 10——1010 14——1110
二转十（倒序连续乘以二的n次方，n从零开始，最后相加）：11010——02^0+1*21+02^2+1*23+1*2^4=26
③
注意：
1.在整数中一般默认是int类型，如果表示长整型需在数值后加L。
2.在小数中默认是double类型，如果想表示float，需在数值后加F/f。
小数据类型-------->大数据类型（自由转换）
小数据类型<--------(小数据类型)大数据类型(强制转换)
3.byte、short、char在运算的过程中，会自动转化成int
4.两个不同数据类型在转换时，结果是大数据类型。
9.3
①
引用数据类型：类 接口 数组
字符串：双引号引起的任何内容都是字符串。
String str="";
算术运算符：
+（正数、加法、连接符）
运用在字符串的连接中是连接符，任何数据和字符串的拼接结果都是字符串。
%（取模/取余数）
++自增
前自增 ++a 先自增，后使用
后自增 a++ 先使用，后自增

• -自减
  前自减 --a 先自减，后使用
  后自减 a-- 先使用，后自减
  ②
  赋值运算符：
  =
  += //a=a+b
  -= //a=a-b
  *=
  /=
  %=
  关系运算符：结果是Boolean(布尔)值
  == 等于
  ！= 不等于

<

=
<=
逻辑运算符：
！ 非
&& 与（并且） 一假即假
|| 或 一真即真
三元运算符
条件？表达式1（true）：表达式2（false）
③
顺序语句:
判断语句
if（布尔表达式）{
执行代码；
}
1.if语句后只有一句，是可以省略{}的，但是不建议省略。
2.在同一作用域，不能重复定义变量。
3.在if判断语句后，不能加； 。
键盘输入使用 Scanner
switch (key) {
case value:
break;
default;
break;
}
9.7
①
1.构建类对象
2.导入该类的包
3.键盘扫描
前包后不包（1，50）有1没有50
循环：
while（循环条件）{
执行代码；
}
1.while（true）{ } 死循环
2.Java中不允许有废话
3.while循环条件后面不能加“；”否则会陷入死循环
②
do—while
do {
执行条件;
} while (循环代码);
注意事项：
1.while是先判断后执行，do-while是先执行后判断
2.do-while不管条件是真是假，至少会执行一次
for循环
for (初始化；判断条件；i++) {
执行代码；
}
for ( ; ; ) { } 是死循环
③
转义字符:把一些特殊的字符通过“\”来去转义。
\b 退格 \t 制表 \n 换行 \r 回车
Break
1.switch：用来结束一个switch case语句
2.循环：结束一个循环语句
continue

1. 跳出本次循环，继续执行下一次循环
   9.8
   ①
   方法(函数):是用来封装统一的代码（功能）。
   作用：复用
   public static void main (String [] args) {
   执行代码;
   }
   public(公共的) static(静态的) 修饰词
   返回类型
   main 方法名(标识符)
   （）代表参数
   函数最大的特点：
   1.被调用
   2.main方法是jvm自动调用的
   方法定义的格式：
   修饰词 返回类型 方法名（参数…）{
   执行代码;
   }
   返回类型：是由调用者来决定的，调用者需要返回什么类型的数据，那么返回类型就是调用者要的类型，
   如果调用者不需要返回数据，那么返回类型为void
   方 法 名 ：只需要符合标识符命名规范即可
   形式参数(形参)：相当于占位符
   定义方法的关键因素:
   1.返回类型
   2.形参
   ②
   注意事项：
   1.静态成员不能调用非静态成员，非静态成员可以调用静态成员。
   2.静态方法直接可以被调用，非静态成员是需要创建对象来调用的。
   方法的重载：一个类中存在两个或两个以上同名的方法称之为重载。
   重载的条件：
   1.方法名必须相同。
   2.参数不同(类型不同，参数个数不同)
   3.与返回类型无关
   return 关键字：
   用在函数中：1.返回数据给调用者
   2.return后没有数据，是用来结束一个函数的
   变量：
   1.局部变量：定义在函数中，必须初始化才能使用，只能在自己的作用域中 使用
   2.全局变量：定义在方法外、类之内，作用范围是整个类，而且具有默认值
   ③
   注意事项：
   1.静态成员不能调用非静态成员，非静态成员可以调用静态成员。
   2.静态方法直接可以被调用，非静态成员是需要创建对象来调用的。
   9.9
   ①
   数组：存储同一类型数据的。
   格式：数据类型 [ ]变量名 = new 数据类型 [数据长度]；
   new是关键字，是用来创建对象的。
   new 数据类型 [数据长度] 创建对象
   赋值给引用类型
   [ ] 代表数组
   动态初始化：int [] arr = new int [10];
   静态初始化：数据类型 [] 变量名 = new 数据类型 [数据长度]；
   注意事项：
   1.数组是存在于堆内存的，并且把内存空间平均分配，以索引的形式标注，索引是从0开始的。
   2.遇到数组、集合，就使用遍历。
   ②
   选择排序法
   ③
   冒泡排序法：相邻两个元素进行比较，如果前者大于后者就交换位置。
   Arrays 数组工具类
   二维数组：就是以一维数组为元素
   int [] [] arr = new int [长度1] [长度2]
   长度1：就是二维数组的长度
   9.9
   ①
   数组：
   特殊的数组（object）：可以存储任意类型的数据
   参数的传递：
   值传递：基本数据类型，注重作用域
   地址值传递：引用类型，传递的是地址值
   局部变量存储在栈里，new对象存储在堆里面
   ②
   字符串创建
   String str=new String(“字符串的内容”)
   String str="";
   == 比较运算符
   应用在基本数据类型比较的是数值，应用在引用数据类型比较的是地址值。
   String字符串是常量，它们的值在创建之后不能更改
   String Buffer 可变字符序列
   ③
   转换方法：
   Char[ ] toCharArray( ) 将字符串转换为字符数组
   Byte[ ] getBytes( ) 将字符串转换为字节数组
   9.14
   ①
   面对对象：Java本身就是面对对象的语言
   对象：Java中一切皆对象，对象是真实存在的
   类：不存在的，抽象出来的
   类中主要的两个内容： 公共的属性：成员变量去定义
   公共的行为：函数来去体现
   现实生活中有很多的对象，同一类型事物具有相同的属性和行为（功能）。
   定义类：
   class 类名 {
   //成员变量
   //成员函数
   }
   创建对象
   Person p1=new Person( );//类 类名=new 类( );
   调用成员：
   对象.变量
   对象.函数
   ②
   成员变量与局部变量的区别：
   定义的位置不同
   成员变量定义在类之内，方法之外
   局部变量定义在方法之内
   作用不同
   成员变量是对象的公共属性
   局部变量是给方法内部使用的
   生命周期不同
   成员变量是伴随着对象存在的
   局部变量只在方法内（作用域）有效
   默认值不同
   成员变量有默认值
   局部变量必须初始化才能使用
   面对对象的三大特征
   封装
   继承
   多态
   ③
   封装：将个人的属性封装起来（可见范围）
   可见范围
   private 本类中可见
   default（无修饰符） 本类 本包
   protected 本类 本包 子类
   public 本类 本包 子类 其他
   9.15
   ①
   静态不能直接访问非静态的成员，非静态可以直接访问静态成员。
   ②
   构造方法
   给对象赋予初始化的值
   修饰词 类名（ ）{

   }
   注意：
   1.没有返回类型
   2.方法名必须和类名一致
   3.如果我们不加任何构造方法，那么jvm会自动加无参构造方法
   1.就近原则
   2.this和static不能共存
   3.this代表调用者，this代表调用者空间
   4.this调用的是全局变量
   ③
   注意事项：
   1.继承是单继承
   2.继承所有的成员，除了私有化的成员和构造方法
   3子类在创建对象过程中会调用无参构造方法
   重写前提是继承
   父类的需求满足不了子类
   1.方法名必须相同
   2.参数必须相同
   3.子类的修饰符必须大于等于父类
   9.16
   ①

②
final关键字 最终的
注意事项：
1.final修饰的变量不能重新赋值
2.final修饰的方法不能被子类所继承 重写
3.final修饰的类不能被继承
③
多态：前提必须是继承或实现
注意事项：
1.多态在调用非静态方法时调用的是子类的
2.多态在调用静态方法时调用的是父类的
3.多态在调用变量时调用的是父类的。
9.17
①
抽象类
注意事项：

1. 方法时抽象方法那么类也必须时抽象类；
2. 父类的方法是抽象方法子类必须去重写抽象方法；
3. 抽象类中既可以有抽象方法也可以有非抽象方法，当然也可以没有抽象方法；
4. 抽象类是一种特殊的类；
5. 抽象类不能直接创建对象
   ②
   接口
   注意事项:
6. 接口也是类的一种，是一种特殊类；
7. 作用：约束，拓展功能；
8. 接口中只能放抽象方法和常量；
9. 接口不能直接创建对象；
10. 接口是多实现。
    ③
    equals方法的本质是比较地址值和==相同，在字符串中比较的是内容
    因为string类重写了equals方法

9.21

总结：
return 结束函数
return加数据，返回数据给调用者
类有两个重要的元素：属性和方法
栈里面一般是值传递，堆里面一般是地址值传递

引用数据类型一般是值传递
“==”比较的是地址值
equals比较字符串的内容

**成员变量和局部变量的区别：
1.位置不同
局部变量是方法内，成员变量是方法外类之内作用于他的作用域，必须初始化，生命周期
2. 作用不同
局部变量是给方法内部使用的，成员变量是对象的公共属性
3. 生命周期不同
局部变量只在方法块（作用域）内有效，成员变量是伴随着对象存在的
4.默认值不同
局部变量必须赋初值才能使用，成员变量有默认值（存放在堆中）
关键字：static静态的 非静态的可以访问静态的，静态的不能直接访问非静态的

抽象类：父类决定不了子类
接口：特殊的类。中只能放抽象方法和常量

面向对象三大特征：封装、继承、多态

封装
private私有化后必须提供两个公开的set/get方法
例:
class Baby{
private int age;
public void setAge(int a){
age=a;
}
public int getAge(){
return age;
}
}
public class(){
public static void main(){
Baby b=new Baby;
b.setAge(3);
System.out.println(b.getAge()); //输出3
}
}

规避空指针：用if语句，如果**不等于null时，返回值。其他时候一概不管了

方法重载：
函数名必须相同、参数列表不同（参数类型、个数不同）、和返回类型无关

构造方法： 无构造方法是单例模式
作用：给对象赋予初始化的值
格式：
修饰词 类名（形参）{ //若不给赋予形参就叫无参构造器
代码
}

注意：

1. 没有返回类型
2. 方法名必须和类名一致
3. 如果我们不加任何构造方法，那么jvm自动加一个无参构造器
   关键字：
   this关键字（用的多的地方是构造方法和set方法，或者成员变量和局部变量重名的时候用来区分）
4. 就近原则
5. this和static不能够共存
6. this代表的是对象，是调用者。this代表调用者空间
7. this调用的是全局变量
   final关键字 最终的
   注意事项：
8. final修饰的变量不能重新赋值
9. final修饰的方法不能够被重写的。严格说是不能被子类继承
10. final修饰的类不能被继承

继承：（包含关系）
4. 继承必须是单继承（可以连续继承，比如继承爷爷的东西）
5. 继承所有的成员（成员变量和成员方法），除了私有化的成员和构造器
6. 子类在创建对象（无参构造方法）过程中会调用父类的无参构造方法

重写：
重写的前提是继承
父类的方法满足不了子类

1. 方法名必须相同
2. 参数必须相同
3. 子类的修饰词必须大于等于父类

多态：前提必须是继承或者实现（实现就是接口）
向上转型
注意事项：

1. 多态在调用非静态方法时调用的是子类的
2. 多态在调用静态方法时调用的是父类的
3. 多态在调用变量时调用的是父类的

super：代表父类空间 this引用本类空间
常用于构造方法，子类的构造方法的第一句必须为super();

intanceof:(判断对象之间是否是属于关系包含关系，前者属于后者就是true，否则false)
例：System.out.println(man intanceof person);//结果true

抽象类：（祖辈级别的类）
抽象类abstract

注意事项：

1. 方法是抽象方法，那么类也必须是抽象类
2. 如果父类的方法是抽象方法那么子类必须去从重写抽象方法
3. 抽象类中即可有抽象方法也可以有非抽象方法，当然也可以没有抽象方法
4. 抽象类是一种特殊的类
5. 抽象类不能直接创建对象（可以用多态，利用子类来帮助他创建对象）
   接口
   注意事项：
6. 接口也是类的一种，是一种特殊类
7. 作用：约束 拓展功能
8. 接口里面放的是常量和抽象方法
9. 接口不能直接创建对象
10. 接口是多实现

---

9.22.

一、异常
可解决的是异常，不可解决的是错误
错误：后缀为erray，硬件问题
异常：后缀为excepsion
异常分为编译异常和运行异常
异常，抛异常(throw（声明）,throws子句)，抓异常（（try,catch）和finally语句）
throwable类是所有错误和异常的父类
------Throwable
toString()
getMessage（）
printStackTrace（）//错误栈，找错误的根源

异常处理的方式：
捕获
try{ //处理的异常代码

}catch(放异常信息){ //处理方法

}catch(Exception e){ //急诊科,都能解决，一般都直接写这个

}finally{ //不管什么情况都会执行这里，就算前面有return都会执行这里，除非前面虚拟机停止System.exit(0);

}
注意事项：

1. 异常代码后的所有代码都不能正常执行了
2. try后面可以跟很多的catch，从小到大去写

抛出异常：
运行异常： 不需要申明
编译异常：RuntimeException及其子类，必须在方法体申明

注意事项：

1. throw和return在函数中的作用是一致的，都是用来结束函数的