- 标识符就是一个名字。
- 语法规则：
- 由数字、字母、下划线、美元符号组成，长度不限。
- 不能由数字开头。
- 不能是关键字。
- 不能是true false null.
- 具有特定用途或被赋予特殊含义的一些单词。
- 逻辑类型：boolean
- 整数类型：byte、short、int、long
- 字符类型：char
- 浮点类型：float、double
-
字节占用数
数据类型 取值范围 占用字节数 byte -27~27-1 1 short -215~215-1 2 int -231~231-1 4 long -263~263-1 8 float 4 double 8 char 0~65535 2 boolean 理论：1位2进制数（1bit） 通常情况：4字节整数 -
注意：
- Java中不存在byte常量，但可以将一定范围内的int型常量赋值给byte型变量。如果要强调一个整数是byte型数据时，可用强制类型转换。short与之类似。
- long类型常量常用后缀L表示。
- char无负数。
- float类型的常量后面必须带后缀F/f。double类型的常量后面可以有后缀D/d,也可以省略。
byte→short→char→int→long→float→double
引用数据类型- 字符串：String 【字符数组】
- 数组
- 对象
- 接口
- 变量
- 变量分为两种：基本类型的变量和引用类型的变量。
- 变量必须先定义后使用，在定义变量的时候，可以给它一个初始值。不写初始值，就相当于给它指定了默认值。
- 变量的一个重要特点是可以重新赋值。
- 变量的作用域：在语句块中定义的变量，它有一个作用域，就是从定义处开始，到语句块结束。超出了作用域引用这些变量，编译器会报错。
- 最小化原则：定义变量时，要遵循作用域最小化原则，尽量将变量定义在尽可能小的作用域。
- 不要重复使用变量名。
- 常量
- 定义变量的时候，如果加上final修饰符，这个变量就变成了常量。
- 常量在定义时进行初始化后就不可再次赋值，再次赋值会导致编译错误。
- 常量名通常全部大写。
- 单目运算符 ：
- 双目运算符 ：
- 三目运算符 ：
- 算数运算符
- 加减运算符（+ 、-）
- 乘、除和求余运算符（* / %）
- 自增自减运算符
- 自增（++）
- 自减（- -）
- 关系运算符
- 大于（>）
- 小于（<）
- 大于等于（>=）
- 小于等于（<=）
- 等于（==）
- 不等于 （!=）
- 逻辑运算符
- 逻辑与（&&）
- 逻辑或（||）
- 逻辑非（!）
- 赋值运算符（=）
- 位（逻辑）运算符
- 按位或（|）
- 按位与（&）
- 按位异或（^）
| 优先级 | 运算符 |
|---|---|
| 1 | [ ] ( ) |
| 2 | 单目运算符（逻辑非、自增、自减、对象归类） |
| 3 | 算数乘除 |
| 4 | 算数加减 |
| 5 | 移位运算（>> << >>>） |
| 6 | 大小关系（>, >=, <, <=） |
| 7 | 相等关系（== 、!=） |
| 8 | 按位与（&） |
| 9 | 按位异或（^） |
| 10 | 按位或（|） |
| 11 | 逻辑与 |
| 12 | 逻辑或 |
| 13 | 三目运算符（ 表达式? 结果1 : 结果2 ） |
| 14 | 赋值（=） |
- 只有左侧为真时，右侧语句才会进行判断。
- 结果 ：全真为真，其余为假，即左右两侧的boolean值全部为真时运算结果才为真。
public class test4 {
private static int j = 0;
private static Boolean methodB(int k) {
j += k;
if(j>10){
return true;
}
return false;
}
public static void methodA(int i,int k) {
j = 0;
boolean b;
b = i < 10 && methodB(k);
System.out.println("--------------");
System.out.println(b);
System.out.println("--------------");
}
public static void main(String args[]) {
System.out.println("one i=5<10 k=11>10 true|true =? expect: true j=11");
methodA(5,11);
System.out.println(j);
System.out.println("two i=5<10 k=5<10 true|false =? expect: false j=5");
methodA(5,5);
System.out.println(j);
System.out.println("three i=11>10 k=5<10 false|false =? expect: false j=0");
methodA(11,5);
System.out.println(j);
System.out.println("four i=11>10 k=11>10 false|true =? expect: false j=0");
methodA(11,11);
System.out.println(j);
}
}
运行结果
2.逻辑或- 只有左侧为假时，右侧语句才会进行判断。
- 结果 ：全假为假，其余为真，即左右两侧的boolean值全部为假时运算结果才为假。
public class test2 {
private static int j = 0;
private static Boolean methodB(int k) {
j += k;
if(j>10){
return true;
}
return false;
}
public static void methodA(int i,int k) {
j = 0;
boolean b;
b = i < 10 || methodB(k);
System.out.println("--------------");
System.out.println(b);
System.out.println("--------------");
}
public static void main(String args[]) {
System.out.println("one i=5<10 k=11>10 true|true =? expect: true j=0");
methodA(5,11);
System.out.println(j);
System.out.println("two i=5<10 k=5<10 true|false =? expect: true j=0");
methodA(5,5);
System.out.println(j);
System.out.println("three i=11>10 k=5<10 false|false =? expect: false j=5");
methodA(11,5);
System.out.println(j);
System.out.println("four i=11>10 k=11>10 false|true =? expect: true j=11");
methodA(11,11);
System.out.println(j);
}
}
运行结果
3.按位与- 不论运算符左侧为true还是false，右侧语句都会进行判断。
- 结果：全真为真，其余为假，即左右两侧的boolean值全部为真时运算结果才为真。
public class test3 {
private static int j = 0;
private static Boolean methodB(int k) {
j += k;
if(j>10){
return true;
}
return false;
}
public static void methodA(int i,int k) {
j = 0;
boolean b;
b = i < 10 & methodB(k);
System.out.println("--------------");
System.out.println(b);
System.out.println("--------------");
}
public static void main(String args[]) {
System.out.println("one i=5<10 k=11>10 true|true =? expect: true j=11");
methodA(5,11);
System.out.println(j);
System.out.println("two i=5<10 k=5<10 true|false =? expect: false j=5");
methodA(5,5);
System.out.println(j);
System.out.println("three i=11>10 k=5<10 false|false =? expect: false j=0");
methodA(11,5);
System.out.println(j);
System.out.println("four i=11>10 k=11>10 false|true =? expect: false j=0");
methodA(11,11);
System.out.println(j);
}
}
结果
4.按位或- 不论运算符左侧为true还是false，右侧语句都会进行判断。
- 结果 ：全假为假，其余为真，即左右两侧的boolean值全部为假时运算结果才为假。
public class test1 {
private static int j = 0;
private static Boolean methodB(int k) {
j += k;
if(j>10){
return true;
}
return false;
}
public static void methodA(int i,int k) {
j = 0;//初始化j的值，避免对下次测试造成影响
boolean b;
b = i < 10 | methodB(k);
System.out.println("--------------");
System.out.println(b);
System.out.println("--------------");
}
public static void main(String args[]) {
System.out.println("one i=5<10 k=11>10 true|true =? expect: true j=11");
methodA(5,11);
System.out.println(j);
System.out.println("two i=5<10 k=5<10 true|false =? expect: ture j=5");
methodA(5,5);
System.out.println(j);
System.out.println("three i=11>10 k=5<10 false|false =? expect: false j=5");
methodA(11,5);
System.out.println(j);
System.out.println("four i=11>10 k=11>10 false|true =? expect: true j=11");
methodA(11,11);
System.out.println(j);
}
}
结果
5.自增自减运算符| 自增/自减 | 处理方式 |
|---|---|
| n++ | 先引用n再加1 |
| n- - | 先引用n再减1 |
| ++n | 先加1再引用n |
| - -n | 先减1再引用n |
三元运算b ? x : y会首先计算b，如果b为true，则只计算x，否则，只计算y。此外，x和y的类型必须相同，因为返回值不是boolean，而是x和y之一。
运算 1.整数运算- 整数运算永远是精确的，两个整数相除只能得到结果的整数部分。
- 整数的除法对于除数为0时运行时将报错，但编译不会报错。
- 整数存在范围限制，计算结果超出了范围，就会产生溢出，而溢出不会出错，却会得到一个奇怪的结果。
- 参与运算的两个数类型不一致，那么计算结果为较大类型的整型。如果把小类型整数赋值给大类型整数会出现编译错误。
- 强制转型，即将大范围的整数转型为小范围的整数，结果可能出错。
- 浮点数常常无法精确表示，浮点数运算会产生误差。
- 比较两个浮点数是否相等：判断两个浮点数之差的绝对值是否小于一个很小的数。
- 参与运算的两个数其中一个是整型，那么整型可以自动提升到浮点型。
- 浮点数运算在除数为0时，不会报错，但会返回几个特殊值：NaN(not a number) Infinity(无穷大) -Infinity(负无穷大)
- 浮点数强制转型为整数。在转型时，浮点数的小数部分会被舍弃。如果转型后超过了整型能表示的最大范围，将返回整型的最大值。
- 短路运算：如果一个布尔运算的表达式能提前确定结果，则后续的计算不再执行，直接返回结果。
- 显示一个字符的Unicode编码，只需将char类型直接赋值给int类型，之后输出int类型的值便得到了字符的Unicode编码。
- 可以直接用转义字符u+Unicode编码来表示一个字符，例如'A' 为 'u0041'
//定义数组：基本数据类型+[]
//初始化数组：new 基本数据类型[数组长度]
int[] i_demo=new int[5];
//可以在定义数组时直接指定初始化的元素，这样就不必写出数组大小，而是由编译器自动推算数组大小。
int[] i_demo2 = new int[] { 68, 79, 91, 85, 62 };
//等价写法 int[] i_demo2 = { 68, 79, 91, 85, 62 };
特点
- 数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false。
- 数组一旦创建后，大小就不可改变。
- 要访问数组中的某一个元素，需要使用索引。数组索引从0开始至数组长度减一结束。
- 可以使用赋值语句修改数组中的某一个元素，例如i_demo[2]=3。
- 可以使用i_demo.length获取数组长度。
- 数组是引用类型，在使用索引访问数组元素时，如果索引超出范围，运行时将报错。
- 数组元素可以是值类型（如int）或引用类型（如String），但数组本身是引用类型。
- for循环
- for each循环
import java.util.*;
public class demo1{
public static void main(String args[]){
//设置一个数组
int[] beforeSortArray = {5,8,6,3,9,2,1,7};
for(int a:beforeSortArray){
System.out.print(" "+a);
}
System.out.println();//换行
System.out.println("++++++++++++++++++++++++")
//冒泡排序
for(int i=0;i=beforeSortArray[j+1]){
b=false;//若本次循环发生交换则将该标志转成false;
int t=beforeSortArray[j];
beforeSortArray[j]=beforeSortArray[j+1];
beforeSortArray[j+1]=t;
}
}
if(b){
break;
}
}
for(int a:beforeSortArray){
System.out.print(" "+a);
}
System.out.println();//换行
System.out.println("++++++++++++++++++++++++");
}
}
输出结果：
5 8 6 3 9 2 1 7
++++++++++++++++++++++++
1 2 3 5 6 7 8 9
++++++++++++++++++++++++
| i | j | 5 | 8 | 6 | 3 | 9 | 2 | 1 | 7 |
|---|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 5 | 8 | ||||||
| 0 | 1 | 6 | 8 | ||||||
| 0 | 2 | 3 | 8 | ||||||
| 0 | 3 | 8 | 9 | ||||||
| 0 | 4 | 2 | 9 | ||||||
| 0 | 5 | 1 | 9 | ||||||
| 0 | 6 | 7 | 9 | ||||||
| 5 | 6 | 3 | 8 | 2 | 1 | 7 | 9 | ||
| 1 | 0 | 5 | 6 | ||||||
| 1 | 1 | 3 | 6 | ||||||
| 1 | 2 | 6 | 8 | ||||||
| 1 | 3 | 2 | 8 | ||||||
| 1 | 4 | 1 | 8 | ||||||
| 1 | 5 | 7 | 8 | ||||||
| 5 | 3 | 6 | 2 | 1 | 7 | 8 | 9 | ||
| 2 | 0 | 3 | 5 | ||||||
| 2 | 1 | 5 | 6 | ||||||
| 2 | 2 | 2 | 6 | ||||||
| 2 | 3 | 1 | 6 | ||||||
| 2 | 4 | 6 | 7 | ||||||
| 3 | 5 | 2 | 1 | 6 | 7 | 8 | 9 | ||
| 3 | 0 | 3 | 5 | ||||||
| 3 | 1 | 2 | 5 | ||||||
| 3 | 2 | 1 | 5 | ||||||
| 3 | 3 | 5 | 6 | ||||||
| 3 | 2 | 1 | 5 | 6 | 7 | 8 | 9 | ||
| 4 | 0 | 2 | 3 | ||||||
| 4 | 1 | 1 | 3 | ||||||
| 4 | 2 | 3 | 5 | ||||||
| 2 | 1 | 3 | 5 | 6 | 7 | 8 | 9 | ||
| 5 | 0 | 1 | 2 | ||||||
| 5 | 1 | 2 | 3 | ||||||
| 1 | 2 | 3 | 5 | 6 | 7 | 8 | 9 | ||
| 6 | 0 | 1 | 2 | ||||||
| 1 | 2 | 3 | 5 | 6 | 7 | 8 | 9 |
import java.util.*;
public class demo2{
public static void main(String args[]){
int[] beforeSortArray = {5,8,6,3,9,2,1,7};
for(int a:beforeSortArray){
System.out.print(" "+a);
}
System.out.println();
System.out.println("++++++++++++++++++++++++");
for(int i=0;i=beforeSortArray[j]){
min=j;
}
}
if(i!=min){
int tmp = beforeSortArray[i];
beforeSortArray[i] = beforeSortArray[min];
beforeSortArray[min] = tmp;
}
}
for(int a:beforeSortArray){
System.out.print(" "+a);
}
}
}
//选择排序不用记录下标的写法
for(int i=0;i
3.插入排序
for(int i=1;i=0 && temp < beforeSortArray[n]){
beforeSortArray[n+1]=beforeSortArray[n];
n--;
}
beforeSortArray[n+1]=temp;
}
4.快速排序
多维数组
1.定义/声明
//1.
int[][] array1=new int[2][3];
int[][] array2=new int[2][];
//2.
int[][] ns = {
{1,2,3},
{2,3,4},
{3,4,5},
};
2.遍历
//1.
for (int[] arrs:ns) {
for (int a:arrs) {
System.out.print(a+" ");
}
System.out.println();
}
//2.
System.out.println(Arrays.deepToString(ns));
3.访问数组元素
System.out.println(ns[1][1]); // 3
流程控制
if条件分支语句
1. if语句
if(条件){
代码块;//条件值为true时执行。
}
2. if-else语句
if(条件){
代码块1;//条件值为true时执行。
}else{
代码块2;//条件值为false时执行。
}
3. if-else if-else语句
if(条件1){
代码块1;//条件1的值为true时执行。
}else if(条件2){
代码块2;//条件1的值为false 且 条件2的值为true 时执行。
}else{
代码块3;//条件1的值为false 且 条件2的值为false 时执行。
}
switch语句
1.语法
switch(表达式){
case 常量值1:
代码块1;
break;//可写可不写
case 常量值2:
代码块2;
break;
...
default:
代码块;
}
2.执行流程
- 计算表达式的值（假设为X）
- 用 X 与case的常量值比较
- 如果有case的常量值等于X ，就执行这个case的代码块，直到碰到break语句为止
- 如果没有case的常量值等于X，就执行default 的代码块
- 如果即没有case的常量值等于X，又没有default，则switch语句不执行
3.注意
- 执行某一个case的代码块，若没有遇到break语句，则会继续执行下一个case的代码块，直至遇到break语句或执行完所有的case的代码块。
- 表达式的值的数据类型应和case后的值的类型一致，或者可以自动转成可以比较的类型。
- 表达式的值的类型只能是 byte short int char enum String.
循环语句
1. for循环
语法
for (初始条件; 循环检测条件; 循环后更新计数器) {
代码块;
}
//执行过程：先初始化计数器，然后，在每次循环前检测循环条件，在每次循环后更新计数器。
//eg:求1-100的和
int sum = 0;
for (int i=1; i<=100; i++) {
sum = sum + i;
}
1.2 for each循环
语法
int[] ns = { 1, 4, 9, 16, 25 };
for (int n : ns) {
System.out.println(n);
}
用途：常用来遍历数组或集合(可迭代的数据类型)
2. while循环
语法
while(条件){
代码块;//条件的值为true 时执行;条件的值为fasle 直接跳出while执行下面的代码。
}
*注意：*先判断循环条件，再执行循环。
3. do-while循环
语法
do{
代码块;
}while(条件)
注意：
- 先执行循环，再进行判断循环条件。若循环条件的值为true则继续循环；反之则推出循环。
- 至少执行一次循环。
break和continue
1.break
- 作用：跳出当前循环，即break所在的循环。
- 注意：使用break会使循环直接终止，顺序执行其他代码。
2.continue
- 作用：跳出本次循环，继续执行下一次循环。
- 注意：使用continue会跳出本次循环，但循环未被终止。
面向对象
特性
- 封装性
- 继承性
- 多态性
类
- 类的目的：抽象出一类事物的共有属性和行为，并用一定的语法格式来描述所抽象出的属性和行为。
- 类是一种用于创建具体（对象）实例的数据类型。
- 类变量叫做对象。
类语法结构
class 名字{ ... }
类体
class 名字{
变量的声明 部分||变量;
方法的定义 部分||方法;
}
成员变量
即类体中声明变量部分所声明的变量，又可称为域变量。
1.类型
Java中任何一种数据类型。
- 基本数据类型
- 引用数据类型
2.有效范围
- 在整个类内生效。
- 与书写位置无关。
3.命名规则
- 符合标识符规定。
- 见名知意。
- 首个单词的首字母小写，其余大写。（驼峰习惯）
方法
1.格式
返回值类型 方法名([参数类型 参数名,...]){
方法体;
}
- 返回值类型：Java中任何一种数据类型，或者无返回值void。
- 方法名命名规则与变量名命名规则一致。
- 参数类型：Java中任何一种数据类型。
- 参数可有可无。
2.局部变量
声明再方法体内的变量与方法的参数被称为局部变量。
有效范围
- 只在方法内有效。
- 与书写位置有关，只在声明与之后的位置生效。
- 若定义再复合语句内则只在复合语句（被大括号包裹的语句即复合语句 { … }）内生效。
成员变量与局部变量
- 若二者名字相同，则再方法内成员变量会被隐藏，暂时失效（普通方式无法使用）。
- 若使用被隐藏的成员变量，则需要使用this关键字。
- 局部变量没有默认值。使用时需要确定其是否有值，否则会编译错误；若不使用未赋值的局部变量，不会出现编译错误。
- 成员变量有默认值。整型：0；浮点型：0.0；Boolean型：false；引用型：null.
//成员变量的默认值
public class demo1 {
public static void main(String[] args) {
test t=new test();
System.out.println("byte:"+t.a);
System.out.println("------------------------");
System.out.println("short:"+t.b);
System.out.println("------------------------");
System.out.println("int:"+t.c);
System.out.println("------------------------");
System.out.println("long:"+t.d);
System.out.println("------------------------");
System.out.println("float:"+t.e);
System.out.println("------------------------");
System.out.println("double:"+t.f);
System.out.println("------------------------");
System.out.println("boolean:"+t.g);
System.out.println("------------------------");
System.out.println("char:"+t.h);
System.out.println("------------------------");
System.out.println("string:"+t.i);
System.out.println("------------------------");
System.out.println("object:"+t.j);
System.out.println("------------------------");
System.out.println("interface:"+t.k);
System.out.println("------------------------");
}
}
class test{
byte a;
short b;
int c;
long d;
float e;
double f;
boolean g;
char h;
String i;
ex j;
ex2 k;
}
class ex{
}
interface ex2{
}
结果
构造方法
1.默认方法
类名(){}
- Java默认的构造函数，无参数，无语句。
- 若类中没有定义构造方法，再创建对象时则会默认调用该构造方法。
2.其他方法
类名([参数类型 参数名,...]){
语句...;
}
- 方法名必须与类名一致。
- 无 返回值类型。
- 构造方法可定义若干，但是，这些构造方法的参差不能相同（参数的个数不同 | 参数个数相同时，对应的参数类型不同）。
- 可以在一个构造方法中调用另一个构造方法。
//若干构造函数写法
类名(){}
//默认构造方法尽量放在其他构造方法的前面
类名(int a){
...;
}
类名(int a,int b){
...;
}
类名(int a,float b){
...;
}
创建对象
1.语法
类名 对象名;//对象的声明
对象名 = new 构造方法;//对象的实例化
类名 对象名 = new 构造方法;
Class Person{
int age;
Person(){}
Person(int age){
this.age=age;
}
}
Person person;
person = new Person();
//person = new Person(18);
Person person = new Person();
//Person person = new Person(18);
2.注意
- 若类中无构造方法，则调用默认构造方法。
- 若没有默认构造方法，但是有其他带参数的构造方法，则创建对象时必须使用带有参数的构造方法
对象的引用
- new运算符只能和类的构造方法进行运算。运算结果是一个16进制的数，这个数称为对象的引用。
- 类体现封装的一种数据类型。
- 类声明的变量叫做对象。
- 对象负责存放引用，以确保对象可以操作分配给该对象的变量和以及调用类中的方法
使用对象
- 使用“.”运算符可以实现对象对自己的变量的访问和方法的调用。
- 程序中那个存在 空对象 编译不会出错。但是不能使用空对象，使用时会出现空指针异常（NullPointerException）
- 一个类创建两个对象后，二者的引用时不同的（即使变量值相同）。
- 若两个对象的引用相同，则二者的实体完全相同。
参数传值
1.传值机制
- 方法中参数变量的值是调用者指定的值的拷贝。
2.基本数据类型参数的传值
-
向参数传递的值的级别不能高于参数的级别
-
方法如果改变参数的值，不会影响向参数“传值”的值。
public class demo3 {
public static void main(String[] args) {
int x=7;
testA testA = new testA();
int change = testA.change(x);
System.out.println("x："+x);
System.out.println("形参x："+change);
}
}
class testA{
public int change(int x){
x+=1;
return x;
}
}
//运行结果：
x：7
形参x：8
3.引用类型参数的传值
- 传值传递的是变量中存放的引用，而不是实体。
- 改变参数变量所引用的实体，则原变量的实体也会发生变化。
- 改变参数变量的引用，则不会影响向其传值 的变量中存放的引用。
public class demo4 {
public static void main(String[] args) {
testA1 testA1 = new testA1();
testA2 testA2 = new testA2(16, 10);
testA2 d1 = testA1.change1(testA2);
System.out.println("d1:"+d1.toString());
System.out.println("testA2:"+testA2.toString());
System.out.println("==========================");
testA2 d2 = testA1.change2(testA2);
System.out.println("d2:"+d2.toString());
System.out.println("testA2:"+testA2.toString());
}
}
class testA1{
//改变参数变量所引用的实体
public testA2 change1(testA2 testA2){
testA2.age+=1;
testA2.number+=2;
return testA2;
}
//改变参数变量的引用值
public testA2 change2(testA2 testA2){
testA2=new testA2(18,1);
return testA2;
}
}
class testA2{
int age;
int number;
testA2(){}
testA2(int age,int number){
this.age=age;
this.number=number;
}
@Override
public String toString() {
return "testA2{" +
"age=" + age +
", number=" + number +
'}';
}
}
//结果：
d1:testA2{age=17, number=12}
testA2:testA2{age=17, number=12}
==========================
d2:testA2{age=18, number=1}
testA2:testA2{age=17, number=12}
可变参数
在声明方法时不给出参数列表中从某项到最后一项参数的名字和个数，但这些参数的类型必须相同。
1.语法
访问权限修饰符 返回值类型 方法名([参数类型 参数名 ...] 参数类型 ... 参数代表)
2.举例
public class demo5 {
public static void main(String[] args) {
demo5 demo5 = new demo5();
int sub1 = demo5.sub(1, 2, 3, 4);
int sub2 = demo5.sub(9, 8, 7);
int sub3 = demo5.sub2(9, 8, 7);
System.out.println("sub1:"+sub1);
System.out.println("sub2:"+sub2);
System.out.println("sub3:"+sub3);
}
public int sub(int ... x){
int sum=0;
for (int i: x) {
sum+=i;
}
return sum;
}
public int sub2(int y,int ... x){
int sum=y;
for (int i: x) {
sum+=i;
}
return sum;
}
}
//结果
sub1:10
sub2:24
sub3:24
3.注意：
- 可变参数的参数代表必须时参数列表的最后一项。
- 可以通过下标运算来表示参数列表中的具体参数，即x[0],x[1]…
- 参数代表.length 为参数代表所代表的参数个数。
static关键字
修饰成员变量
- 被static关键字修饰的成员变量被称为类变量或静态变量。
- 所有类对象共享类变量。一个对象改变类变量，则所有的对象的类变量跟着改变。
- 可以通过类名.变量名访问类变量。
- 分配内存的时间：类被加载到内存的时间，类变量就分配了内存空间。
修饰方法
- 被static关键字修饰的方法被称为类方法或静态方法。
- 类被加载到内存的时间，类方法就分配了入口地址。
- 可以通过类名.方法名调用方法。
- 类方法不能操作实例变量。
重载（overload）
两种多态的一种，功能多态性。
语法规则：
- 方法名必须相同。
- 返回值类型、参数名尽量相同。
- 参数不同，即（个数不同 || 个数相同但对应的参数类型不同）
注意
避免重载出现歧义，尤其是当参数类型的种类和精度相近时。
public class demo1 {
public static void main(String[] args) {
test1 test1 = new test1();
test1.show(10,88.9);
test1.show(10,88);//出现歧义 ，编译出错：对show的引用不明确
}
}
class test1{
public void show(int age, double score){
System.out.println("小明"+age+"岁，考了"+score+"分");
}
public void show(double score ,int age){
System.out.println("小明"+"考了"+score+"分"+age+"岁");
}
}
this关键字
1.含义
this ，表示某个对象。
2.适用区域及意义
- 实例方法：代表正在调用该方法的对象。
- 构造方法：代表该构造方法所创建的对象。
3.在实例方法中调用成员变量的默认格式
- 实例变量：this.变量名
- 静态变量：类名.变量名
4.在实例方法中调用方法的默认格式
- 实例方法：this.方法名
- 静态方法：类名.方法名
5.注意点
- 通常情况下，可以省略实例成员变量和静态变量以及实例方法和静态方法 前的this或类名
- 若成员变量与局部变量的名字相同则不能省略this
访问权限
指的是对象是否可以通过.运算符操作自己的变量或调用类中的方法。
1.修饰符
- public
- protected
- private
2.不同修饰符的权限比较
同一类中 同一包中（子类和无关类） 不同包的子类 不同包的无关类 public ✓ ✓ ✓ ✓ protected ✓ ✓ ✓ 友好的 default ✓ ✓ private ✓
3.注意
- 若在不同包的无关类中使用子类创建了一个对象，通过该对象只能访问到子类自己定义的protected成员变量和方法。
- 若在同包的无关类中使用子类创建了一个对象，通过该对象可以访问到子类自己定义的和继承的protected成员变量和方法。
基本数据类型的类封装
1.封装类
- Double和Float
- Byte、Short、Integer、Long
- Character
2.自动装箱与拆箱
- 自动装箱：把基本数据类型添加到数据结构中时，系统会自动完成基本数据类型到相应对象的转换。
- 拆箱：从数据结构中获取对象时，如果是基本数据类型的封装对象，系统会完成对象到基本数据类型的转换。
继承
由已有类创建新类的机制。
1，关键字
extends
class A{ ... }
class B extends A{ ... }
注意：子类只能有一个父类。
2.子类和父类在同一包内的继承性
- 子类只能继承非private修饰的成员变量和方法。
3.子类和父类不在同一包内的继承性
- 子类只能继承protected、public修饰的成员变量和方法。
4.子类对象的特点
- 用子类的构造方法创建一个子类对象时，不仅子类中声明的成员变量被分配了内存空间，父类的也被分配了内存空间。
- 父类的部分成员变量被子类继承成为子类对象的变量。父类其余的变量不能被子类定义的方法操作，但能被继承的方法操作。
5.成员变量的隐藏
子类声明的变量的名字与子类继承的成员变量的名字相同时，继承的成员变量会被隐藏。
- 子类定义的方法操作的成员变量时子类自己定义的成员变量。
- 子类继承的方法只能操作子类继承的成员变量和被隐藏的成员变量。
- 子类定义的方法能操作新定义的成员变量和继承的成员变量，无法操作子类隐藏的成员变量。
6.重写（override）
语法规则
子类可以重写从父类继承的方法。（子类只能修改方法体其余均不能改动）
目的
- 隐藏继承的方法，通过重写可以把父类的状态和行为改变为自身的状态和行为。
- 重写过的方法，无法操作被隐藏的成员变量和方法。
- 重写过的方法，可以操作继承的成员变量和方法，也可以操作新定义的成员变量和方法。
注意
- 重写时不能降低访问权限，可以提高。
7. super关键字
- 使用super关键字操作被隐藏的成员变量和方法。
- 调用父类的构造方法。必须在子类构造方法的第一条语句。
final关键字
- 修饰类：则该类不能被继承，没有子类。
- 修饰方法：子类必须继承且不能重写。
- 修饰变量：该变量则成为了常量，不能发生变化，声明时必须赋初值。
对象的上转型对象
1.语法
父类 对象名 = new 子类构造方法;
2.特性
- 上转型对象不能操作子类定义的成员变量、调用子类定义的方法。
- 上转型对象可以操作子类继承或隐藏的成员变量、调用子类继承的方法或重写的实例方法。
3. 注意
- 父类对象的引用不能赋值给子类对象。
- 若子类重写了父类的静态方法，上转型对象只能调用父类的静态方法。
抽象类和抽象方法
关键字：abstract
语法：
abstract class A{ ... } //抽象类
abstract 返回值类型 方法名([参数类型 参数名...]); //抽象方法
注意
- 抽象方法必须时实例方法，且没有方法体。
- 抽象类中可以有抽象方法，也可以有普通方法。
- 抽象类中可以没有抽象方法。
- 抽象类不能new出对象。
- 抽象类的非抽象子类必须重写抽象方法。
- 抽象类的抽象子类可以重写也可以继承抽象方法。
- 可以作为上转型对象
接口
关键字：interface
语法：
权限访问修饰符 interface 接口名{
[public static final] 类型 常量名;
[public abstract] 返回值类型 方法名;
}
注意：
- 不能定义变量。
- 不能定义普通方法。
- []内的修饰符可以省略。
- 接口可以继承接口。
1.实现接口
关键字：implements
语法：
class A implements 接口1,[接口2 ... ]
注意：
- 接口的实现类（非抽象）必须重写接口中的方法。
- 接口的实现类（抽象类）可以重写也可以直接拥有接口方法。
- 重写接口方法时必须遵循重写的规则。
- 父类实现接口则子类自动实现接口。
2.接口回调
接口变量
接口名 变量名 = 实现类对象的引用值
含义：
接口变量可以调用被实现类实现的接口方法。前提：接口变量已被赋予实现类对象的引用，即已被赋值。
3.接口思想
-
要求某些类有相同名字的方法，但是方法的内容不同。
-
接口的实现类在有相同名称的方法时，并不一定具有相同的父类。
4.接口多态
- 不同类在实现统一接口时，可以具有不同的实现方式（方法体不同）。
- 接口变量回调接口方法时就可以具有多种形态。
5.接口类型参数
- 将实现接口的类对象的引用传递给接口参数。
- 接口参数可以回调类实现的接口方法。
6.抽象类和接口
抽象类 接口 可以有也可以没有 可以有 抽象方法 可以有也可以没有 不能有 非抽象方法 可以有也可以没有 不能有 变量 可以有也可以没有 可以有 常量
内部类
匿名类
异常类 
