java笔记

java笔记
** 命名规范：**首字母大写，后面每个单词首字母大写（大驼峰）HelloWrold

变量名规范：首字母小写，后面每个单词首字母大写（小驼峰）helloWorld

方法变量名规范：同变量名

常量：在程序运行期间，固定不变的量

常量分类
- 字符串常量：凡是用双引号引起来的部分，叫做字符串常量例如：“abc” "hello"
- 整数常量：直接写上的数字，没有小数点例如：100，2000，0，-250
- 浮点型常量：直接写上的数字，有小数点例如：2.5
- 字符常量：凡是用单引号引起的单个字符，就是字符常量例如：’A‘ ' B' '中' ’9‘ 不能为空，有且只有一个字符
- 布尔常量：只有量中取值 true和false
- 空常量：null,代表没有任何数据
基本数据类型：
1. 整数 byte short int long -----------默认interesting，使用龙加后缀L
2. 浮点数 float double --------默认double，使用float加后缀F
3. 字符 char
4. 布尔 boolean
引用数据类型：**类，数组，端口

变量：程序运行期间，内容可以发生改变的量

创建一个变量： 变量类型变量名称 =数据值
- 变量名称=数据值；
day02

A 65

a 97

使用变量时候的注意事项：
1. 如果创建多个变量，变量名称不能重复
2. 对于float和long类型，加字母后缀F，L
3. 如果使用byte和short变量，右侧数据值不能超过左侧类型的范围
4. 作用域：定义变量的第一行开始，到直接所属的大括号结束为止
```
 public class HelloWorld{
 public static void main (String[] args){
 {int num6=10
 System.out.println(num6);
 }
 //System.out.println(num6);超出大括号范围，变量不能使用
 }
 }
```
创建变量：
```
 //同时创建三个int 变量,各自赋值
 int a,b,c;
 a=1; 
 b=2;
 c=4;
 //同时创建三个int变量，并且同时各自赋值
 int x=1,y=2,c=3;
 System.out.println(a);
 System.out.println(b);
 System.out.println(c);
```
数据类型转换
```
 System.out.ptintln(1024);//这就是一个整数，默认int类型
 System.out.ptintln(2.3);//这就是一个浮点数，默认就是double类型
```
当数据类型不一样时，就会发生数据类型转换。

自动类型转换（隐式）
1. 特点：代码不需要特殊处理，自动完成。
2. 规则：数据范围从小到大
```
 //左边long右边int
 //int--->long，符合了数据范围从小到大的要求
 //发生自动转换
 long num1=100；
 System.out.println(num1);
 
 //左边double右边float
 //float--->double，符合从小到大的规则
 //发生了自动类型转换
 double num2=2.5F;
 System.out.println(num2);
 
 //long--->float,范围更大的是float，符合从小大大的规则
 //发生自动转换
 float num3=20L
 System.out.println(num3);
```
强制类型转换（显式）

特点：需要进行特殊的格式处理，不能自动化完成 格式：范围小的类型范围小的变量名 =（范围小的类型）原本范围大的数据

注意事项：
1. 强制类型转换一般不推荐使用，可能有精度损失，数据溢出
2. byte/short/char着三种类型都可以发生属性运算，例如加法'+'
3. byte/short/char着三种类型在运算的时候，都会被首先提升成为int类型，然后计算
4. Boolean不能发生转换
```
 //long-->int,不是从小到大
 int num=(int)100L;
 System.out.println(num);
 
 //long强制转化为int类型
 int num=(int)600000000000L;
 System.out,println(num);//数据溢出
 
 double--->int,强制类型转换
 int num3=(int)3.99;
 System.out.println(num3);//3,不是四舍五入，所有的小数位都会被舍弃掉
 
 
 char zifu1='A';//这是一个字符型变量，里面写的是大写字母'A'
 Syste.out.println(zifu1+1);//66,也就是大写字母A被当作65处理
 //char类型运行了数学运算，就hi按一定的规则翻译为数字
 
 
 byte num4=40；
 byte num5=50；
     //byte+byte---->int+int---->int
 int result1=num4+num5;
 System.out.println(result1);//90
 
 
 //btye+short----->int+int------->int
 short num6=60;
 //int强制转换为short：必须保证逻辑上真实大小本来就没有超过收人头范围，否则会发生数据溢出
 short result2=(short)(num4+num6);
```
day03
运算符

1.算数运算符

加减乘除：+ — * /

加号'+'的三种用法：
1. 对于数值来说，计算之前，char会被提升为int，然后计算
2. char类型字符，和itn类型数字，之间的对照关系表：ASCLL,UNicde
3. 对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。
```
 String str="java";
 System.out.println(str2+20+30);//java2030
 System.out.println(str2+（20+30）);//java50
```
自加自减

可以单独使用也可以混合使用
- ++num：先++，变量马上加1，然后打印结果，先加后用
- num++：先使用变量，然后再让变量+1，先用后加
  
  2.复制运算符
注意事项：
- 只有变量可以赋值，常量不可以 //50=20是不可以的
- 复合赋值运算符其中隐含了一个强制类型转换
```
 byte num=30;
 //num=byte+int
 //num=int+int
 //num=(byte)int
 num+=5
     System.out.println(num);
```
3.比较运算符

如果进行多次判断，不能连着写

4.逻辑运算符
- 与（并且）&& 全都是true才是true：否则就是false
- 或（或者）|| 至少一个是true，才是true：全部是false才是false
- 非（取反）！本来是true，变成false：本来是false，变成true
&&，|| ，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码不在执行

三元运算符
1. 一元：只要一个数据就可以进行操作的运算符例如：取反！，自增，自减
2. 二元：需要两个数据才可以进行操作的运算符例如：加法，赋值
3. 三元：要三个数据才可以进行操作的运算符
格式：

数据类型变量名称 =条件判断？表达式A：表达式B；

如果是true将表达式A赋值给左侧变量

如果是false将表达式B赋值给左侧变量
```
 int a=20;
 int b=10;
 //数据类型   变量名称   =条件判断？表达式A：表达式B；
 int max=a>b?a:b;
```
注意事项：

必须同时保证表达式A和B都符合左侧数据类型的要求

三元运算符的结果必须被使用
```
 int result=3>4?2.5:20;//错误写法，变量类型不同
 System.out.println(a>b?a:b);//正确写法，直接输出
```
定义方法

定义方法的格式：

public static void 方法名称（）{

方法体 }

方法名称的命名规则和变量一样，使用小驼峰。

方法体：也就是大括号当中可以包含任意条语句。

方法定义注意事项：
1. 方法定义的先后顺序无所谓。
2. 方法的定义不能产生嵌套包含关系。
3. 方法定义好了之后，不会执行，如果想执行，一定要进行方法的调用。
方法调用的格式：
```
 public class Demo(){
 public static void main(String[] args){
     cook();//调用
 }
 //定义方法
 public static void cook(){
 System.out.println("xicai");
 System.out.println("qiecai");
 }
 }
```
对于byte/short/char/三种类型来说如果右侧赋值的数值没有超过范围，那么Javac编译器将会自动为我们补上一个（byte）（short）（char）

如果在给变量赋值的时候，右侧的表达式全都是常量，没有变量，那么编译器javac将hi直接将若干个常量表达式计算得到结果。

short result=13；//右侧的常量数值没有超过左侧的范围，所以正确。

判断语句1---if

if语句第一中格式：if
```
 if(关系表达式){
     语句体；
 }
```
第二种格式：if....elsed
```
 if（关系表达式）{
 语句体1；
 }else{
 语句体2；
 }
```
```
 int num=13;
 if(num%2==0){
     System.out.println("偶数")；
 }
 else{
     System.out.println("基数")；
 }
```
```
 if（关系表达式）{
 语句体1；
 }else if(判断语句2){
 语句体2；
 }else if（判断语句n){
  语句体n；
 }   
```
第三章选择语句

3.1选择语句---switch

格式
```
 switch(表达式){
         case1常量值:
             语句体1；
             break;
         case2常量值2:
             语句体2；
             break;
         .....
         default:
             语句体n；
              break;
 }
```
```
 int num=1;
 switch(num){
     case 1:
         System.out.println("星期一");
         break;
     case 2:
         System.out.println("星期二");
         break;
     case 2:
         System.out.println("星期三");
         break;
     case 3:
          System.out.println("四")；
          break;
      defualt:
          System.out.println("数据不合理")；
          break;
 }
```
switch使用注意事项：

1.多个case后面的值不可以重复；

2.switch后面小括号但当中只能是下列数据类型：

基本数据类型:byte/short/char/int

引用数据类型：String字符串，enum枚举

day04
第四章循环语句

循环的结构分为资格部分：

初始化语句：在循环开始最初执行，而且只做唯一一次。

条件判断：如果成立，则循环继续；如果不成立，则退出循环

循环体：重复要做的事情内容，若干行语句。

步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。

for循环

for(int i=1;i<=100;i++){
System.out.println("你好")；
}

while循环语句

标准格式

while(条件判断){
循环体;
}

扩展格式

初始化语句；
while(条件判断){
循环体；
步进语句；
}

int i;
while(i<=10){
System.out.println("你好")；
i++
}

do-while循环

标准格式

初始化语句；
do{
循环体；
}while(条件判断);

扩展格式

do{
循环体；
步进表达式；
}while(布尔表达式)；

三种循环的区别

如果条件判断从来没有满足过，那么for循环和while循环执行0此，但是do-while循环至少会执行一次

for循环的变量在小括号当中定义，只有循环内部才能使用

break关键字：

可以用在switch语句中，一旦执行，整个switch语句立刻结束

还可以用在循环语句中，一旦执行，整个循环语句立即执行

凡是次数确定的场景多用for循环；否则多用while循环；

另一种循环控制语序continue关键字

一旦执行立刻跳过当前循环剩余内容，马上开始下一次循环

idea常用快捷键

ALT+Enter 导入包，自动修正代码

Ctr+y 删除光标所在行

Ctrl+D 复制光标所在行内容

Ctrl+ALT+L 格式化代码

ctrl+/ 单行注释，再按取消注释

定义方法的完整格式：

修饰符返回值类型方法名称（参数类型参数名称，.......){

方法体；

return 返回值；}

修饰符：现阶段的固定写法public static

返回类型值：也就是方法最终产生的数据结果是什么类型

参数类型：进入方法的数据是什么类型

参数名称：进入方法的数据对应的变量名称

PS：参数如果有多个，使用逗号分隔

方法体：方法需要做的事情，若干行代码

return:两个作用，第一停止当前方法，第二将后面的返回值还给调用处

返回值：也就是方法执行后最终产生的数据结果

注意：return后的返回值必须和方法名称前面的返回值类型保持对应

定义一个两个int数字相加的方法。三要素：

返回值类型：int

方法名称：sum

参数列表：int a , int b

sum(a:10,b:20)//单独调用
System.out.prntln(sum(10,20))//打印调用
int number=sum(15,25,);//赋值打印
System.out.println("变量的值："+number);//赋值打印
public static int sum(int a;int b){
int result=a+b;//方法体
return result;//返回值
}

方法的三种调用方法：

单独调用：方法名称（参数）；

打印调用：System.out.println(方法名称(参数))；

赋值调用：数据类型变量名称=方法名称(参数)；

对比有参数和无参数

有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的额时候，就是有参

无参数：小括号当中留空。一个方法不需要任何数据条件，自己能独立完成任务，就是午餐。

对比有返回值和无返回值

有返回值：带着返回值返回 ----可以使用单独调用，打印调用，赋值调用

无返回值：什么都不带 ------只能使用单独调用

{//有返回值的调用
int num=getsum(10,20);//赋值调用
System.out.getsum(num);//赋值调用
System.out.println(getsum(2,3))；//打印调用
getsum(3,5)；//直接调用

//无返回值
int num2=printSum(10,20)//错误
printSum(10,20)//单独调用

}
//定义一个方法，负责两个数字相加，返回值int，谁调用就给谁结果，三种调用方法都可以用
public static int getsum(int a,int b){
int result=a+b;
return result;
}
//没有返回值，不会把结果告诉任何人，
//而是自己打印输出，只能用单独调用
public static void printSum(int a,int b){
int result=a+b;
System.out.println("结果是"+result);
}

重载(Overload)

方法重载的基本使用方法

方法重载：多个方法的名称相同，但是参数列表不一样。

好处：只需要记住一个方法名称，就可以实现类似的多功能

//调用
System.out.println(sum(10,20));
System.out.println(sum(10，20，30))；
//定义方法
public ststic int sum(int a,int b){
System.out.println("有两个的参数方法执行")
return a+b;
}

public ststic int sum(int a,int b,int c){
System.out.println("有三个的参数方法执行")
return a+b;
}

相关因素：

参数个数不同

参数类型不同

参数的多类型顺序不同

元素无关：

与参数的名称无关

与方法的返回值类型无关

day05

第四章循环语句

循环的结构分为资格部分：

初始化语句：在循环开始最初执行，而且只做唯一一次。

条件判断：如果成立，则循环继续；如果不成立，则退出循环

循环体：重复要做的事情内容，若干行语句。

步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。

for循环

for(int i=1;i<=100;i++){
System.out.println("你好")；
}

while循环语句

标准格式

while(条件判断){
循环体;
}

扩展格式

初始化语句；
while(条件判断){
循环体；
步进语句；
}

int i;
while(i<=10){
System.out.println("你好")；
i++
}

do-while循环

标准格式

初始化语句；
do{
循环体；
}while(条件判断);

扩展格式

do{
循环体；
步进表达式；
}while(布尔表达式)；

三种循环的区别

如果条件判断从来没有满足过，那么for循环和while循环执行0此，但是do-while循环至少会执行一次

for循环的变量在小括号当中定义，只有循环内部才能使用

break关键字：

可以用在switch语句中，一旦执行，整个switch语句立刻结束

还可以用在循环语句中，一旦执行，整个循环语句立即执行

凡是次数确定的场景多用for循环；否则多用while循环；

另一种循环控制语序continue关键字

一旦执行立刻跳过当前循环剩余内容，马上开始下一次循环

idea常用快捷键

ALT+Enter 导入包，自动修正代码

Ctr+y 删除光标所在行

Ctrl+D 复制光标所在行内容

Ctrl+ALT+L 格式化代码

ctrl+/ 单行注释，再按取消注释

定义方法的完整格式：

修饰符返回值类型方法名称（参数类型参数名称，.......){

方法体；

return 返回值；}

修饰符：现阶段的固定写法public static

返回类型值：也就是方法最终产生的数据结果是什么类型

参数类型：进入方法的数据是什么类型

参数名称：进入方法的数据对应的变量名称

PS：参数如果有多个，使用逗号分隔

方法体：方法需要做的事情，若干行代码

return:两个作用，第一停止当前方法，第二将后面的返回值还给调用处

返回值：也就是方法执行后最终产生的数据结果

注意：return后的返回值必须和方法名称前面的返回值类型保持对应

定义一个两个int数字相加的方法。三要素：

返回值类型：int

方法名称：sum

参数列表：int a , int b

sum(a:10,b:20)//单独调用
System.out.prntln(sum(10,20))//打印调用
int number=sum(15,25,);//赋值打印
System.out.println("变量的值："+number);//赋值打印
public static int sum(int a;int b){
int result=a+b;//方法体
return result;//返回值
}

方法的三种调用方法：

单独调用：方法名称（参数）；

打印调用：System.out.println(方法名称(参数))；

赋值调用：数据类型变量名称=方法名称(参数)；

对比有参数和无参数

有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的额时候，就是有参

无参数：小括号当中留空。一个方法不需要任何数据条件，自己能独立完成任务，就是午餐。

对比有返回值和无返回值

有返回值：带着返回值返回 ----可以使用单独调用，打印调用，赋值调用

无返回值：什么都不带 ------只能使用单独调用

{//有返回值的调用
int num=getsum(10,20);//赋值调用
System.out.getsum(num);//赋值调用
System.out.println(getsum(2,3))；//打印调用
getsum(3,5)；//直接调用

//无返回值
int num2=printSum(10,20)//错误
printSum(10,20)//单独调用

}
//定义一个方法，负责两个数字相加，返回值int，谁调用就给谁结果，三种调用方法都可以用
public static int getsum(int a,int b){
int result=a+b;
return result;
}
//没有返回值，不会把结果告诉任何人，
//而是自己打印输出，只能用单独调用
public static void printSum(int a,int b){
int result=a+b;
System.out.println("结果是"+result);
}

重载(Overload)

方法重载的基本使用方法

方法重载：多个方法的名称相同，但是参数列表不一样。

好处：只需要记住一个方法名称，就可以实现类似的多功能

//调用
System.out.println(sum(10,20));
System.out.println(sum(10，20，30))；
//定义方法
public ststic int sum(int a,int b){
System.out.println("有两个的参数方法执行")
return a+b;
}

public ststic int sum(int a,int b,int c){
System.out.println("有三个的参数方法执行")
return a+b;
}

相关因素：

参数个数不同

参数类型不同

参数的多类型顺序不同

元素无关：

与参数的名称无关

与方法的返回值类型无关

数组

数组的概念：是一种容器，可以同时存放多个数据值

**数组的特点：**

数组是一种引用数据类型

数组当中的多个数据，类型必须统一

数组的长度在程序运行期间不可改变

数组的初始化：在内存中创建一个数组，并且向其中赋予一些默认值

常见的两种初始化方式：

静态初始化（指定内容）

动态初始化（指定长度）

动态初始化数组的格式：

数据类型 [] 数组名称 =new数据类型 [数组长度]

解析含义：

左侧数据类型：也就是数组当中保存的数据，都是统一的什么类型

左侧的中括号：代表我是一个数组

左侧的中括号：做数组取一个名字

右侧的new：代表创建数组的动作

右侧的数据类型：必须和左侧的数据类型保持一致

右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字

//创建一个数组，里面可以存放300个int数据
int [] arrayA=new int[300];
//创建一个数组，能存放10个double类型的数据
double [] arrayB =new double[10];
//创建一个数组，能存放5个字符串
String [] arrayC =new String [];

//拆分为两个格式
int[] arrayC;
arrayC=new int[5];

静态初始化创建的时候，不直接指定数据个数，而是直接指定数据内容

静态初始化没有指定长度，但仍然可以自动推算得到长度

静态初始化基本格式：

数据类型 [] 数组名称=new 数据类型 []{元素一，元素二.......

}；

int [] arrayA =new int[]{15,25,35}
//直接创建一个数组，装的int数字15，25，35长度为3
String [] arrayB =new String[]{"Hello","Wrold"}
//创建数组，用来装字符串："Hello","World"长度为2

静态初始化的省略格式：不能拆分为两个步骤

数据类型 [] 数组名称={ 元素一，元素二 }

int [] arrayA={10,20,30}
//拆分为两个步骤
int[] arrayB;
arrayB=new int[]{
11,21,31
}

使用建议：如果不确定数组当中的具体内容，用动态初始化；否则用静态初始化

数组元素的访问

访问数组元素格式：数组名称[索引值]

索引值：就是一个int数字，代表数组当中的编号。

【注意】：索引值从0开始，直到数组长度-1位置

使用动态初始化的时候，其中的元素会自动拥有一个默认值：

整数类型：默认值为0

浮点类型：默认值为0.0

字符类型：默认值为'\u000'

布尔类型：默认值为false

引用类型：默认值为null

静态初始化也是有默认值的过程，不过系统马上将大括号里面的值给默认值替换

Java的内存需要划分为5个部分

1.栈（Stack）：存放的都是方法中的局部变量

方法运行一定要在栈当中

局部变量：方法的参数，或着是方法{}内的变量

作用域：一旦超出作用域，立刻从栈内存当中小时

2.堆（Heap）：凡是new出来的东西，都在堆当中。

堆内存里面的东西都有一个默认值：16进制

堆内存里面的数据，都是默认值。规则：

整数类型：默认值为0

浮点类型：默认值为0.0

字符类型：默认值为'\u000'

布尔类型：默认值为false

引用类型：默认值为null

方法区（Method Area）：存储.class相关信息，包含方法的信息

本地方法栈（Native Method Stack）:与操作系统相关

寄存器（pc Register）：与CPU相关

常见异常-空指针异常

所有引用类型变量，都可以赋值null，但是代表其中什么都没有

数组必须进行new初始化才可以使用其中的元素

如果只是赋值一个null，没有进行new创建，将会发生空指针异常

获取数组长度：

数组名称.length

int [] array=new int[3];
int [] array={1,2,3,4,5,6,7,8,9}
int len=array.length;
System.out.println(len)；

数组一旦创建，程序运行期间，长度不可以改变，获取数组长度。

int [] attayC=new int[3];
System.out.println(arrayC.length);//3
arrayC=new int[5];
System.out.println(arrayC.length);//5

array.length：指的是输出数组当中每一个

数组遍历输出：对数组当中的每一个元素进行逐一输出

int [] array={1,2,3,4,5}
//for循环
for(int i=0;i<5;i++){
sout(array[i])
}
for(int i=0;i<array.length;i++){
sout(array[i])
}
//可以用简便方法
arry.fori

元素组的反转：其实就是对你的位置的元素交换

数组作为方法返回值，返回地址：

int [] result=caculate(10，20，30)；

面向过程：

当需要实现一个功能的时候，每一个具体的步骤都要亲历亲为，详细处理每一个过程

package day02;
//面向过程
public class Demo01printarray {
public static void main(String[] args) {
int [] array={1,2,3,4,5};

System.out.print("[");
for (int i=0;i<array.length;i++){
if (i==array.length-1){
System.out.print(array[i]+"]");
}else
System.out.print(array[i]+",");

}
}
}

面向对象：

本质：以类的方式组织代码，以对象的组织（封装）数据

当需要实现一个功能的时候，不关心具体的步骤，而是找一个已具有该功能的人帮我做这件事。

System.out.println(Arrays.toString(array));

System.out.println(Arrays.toString(array));

特点：

面向对象思想是一种更符合我们的思考习惯的思想。将复杂的事情简单化包含了三大基本特征即封装，继承，多态

1.2类和对象

类：是一组相关属性和行为的集合。可以看成是一类事务的模板，使用事务的属性特征和行为特征来描述该类事务

类与对象的关系

类是对一类事物的描述，是抽象的

对象是一类事务的实例，是具体的

类是对象的模板，对象是类的实体

1.3类的定义

定义类注意事项：

1.成员变量的直接定义在类当中的，在方法外边

2.成员方法不要写static关键字

成员变量（属性）

成员方法（行为）

public class Student{
String name://姓名
int age;//年龄
public void eat(){
sout("吃饭")
}
public void sleep(){
sout("睡觉")
}
}

类的使用：

通常情况下，类不能直接使用，需要根据类创建一个对象才能使用。

1.导包：也就是指出需要使用的类，在什么位置

import包名称.类名称;

import cn.intcast.day06.demo01.student;

对于和当前类属于同一个包的情况下，可以省略导报语句不写

2.创建格式

类名称对象名=new 类名称（）；

student stu=new Student（）；

3.使用，分两种情况：

使用成员变量：对象名.成员变量名

使用成员方法：对象名.成员方法名（参数）

（也就是，想用谁，就用对象名点儿谁）

增强for循环

int [] array={1,2,3,4,5}
for （int array:arrays）{//没有下标
sout(array)//输出每个元素
}

1Scanner对象

next和next Line（）方法

next不能得到带有空格的字符串，以空格为结束符

fLine以Enter为结束符，可以获得空白

可变参数：

在方法声明，在指定参数类型后加一个省略号（...）

一个方法只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在他之前声明。

public static void printMax(double...number)

二维数组

int [] [] array={{1,2}{2,3}}

方法调用

静态方法：有static的方法，再另一个页面调用的时候

可以用 类名.方法名（）；

非静态方法调用：没有static的方法，在另一个页面调用的时候，需要实例化这个类new

对象类型 对象名=new student（）;

例如：一个页面为 class Students方法名为say

则到另一个页面调用的时候：

Students student=new Students ();

student.say()

非静态方法的调用：

new 类名.方法名（）

静态方法的调用：

类名.方法名（）；

两个方法同为静态或者非静态的时候可以相互调用

类

定义类的方法：

//属性：字段
String name;
int age;
//方法
public void study(){
sout(this.name+"在学习")//this代表当前的类
}
//实例化调用

对象是具体的事物，类是抽象的，是对对象的抽象，雷士对象的模板

类是抽象的，需要实例化

实例化后会返回一个自己的对象

xm对象就是一个Students

Students xm = new Student();

构造器

alt+insert：快捷生产构造器

一个类即使什么都不写，他也会存在一个方法，

无参构造：

public person（）{}
//构造器
//无参构造

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：

必须和类的名字相同

必须没有返回值类型，也不能写void

构造器得到作用：

可以实例化初始值

核心作用：

1.使用new关键字，本质实在调用构造器

2.构造器用来初始化对象的值

String name：
//无参构造
public person（）{
this.name="qj"
}

有参构造：

一旦定义了有参构造，无参必须显示定义，否则无效

public Person(String name){
this.name=name;
}

注意点：定义一个有参构造之后，如果想要使用无参构造，显示的定义一个无参构造

this.当前类=

构造器

alt+insert：快捷生产构造器

一个类即使什么都不写，他也会存在一个方法，

无参构造：

public Person（）{}
//构造器
//无参构造

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：

必须和类的名字相同

必须没有返回值类型，也不能写void

构造器得到作用：

可以实例化初始值

核心作用：

1.使用new关键字，本质实在调用构造器

2.构造器用来初始化对象的值

String name：
//无参构造
public person（）{
this.name="qj"
}

有参构造：

一旦定义了有参构造，无参必须显示定义，否则无效

public person（）{}//有参构造的时候必须有无参构造，空着
public Person(String name){
this.name=name;
}

注意点：定义一个有参构造之后，如果想要使用无参构造，显示的定义一个无参构造

this.当前类=

什么是类

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事务的属性特征和行为特征来描述该类事务。

属性：就是该类事务的状态信息。Java中叫做成员变量

String name;

int age;

行为：就是该事务能做什么。Java中叫做成员方法

例如：小猫

属性：名字、体重、年龄、颜色

行为：跑步、走、叫

什么是对象

对象：是一类事务的具体体现。对象是类的一个实例

类与对象的关系

类是对一类事物的描述，是抽象的

对象是一类事务的实例，是具体的

类是对象的模板，对象是类的实例

类的定义

类当中写方法的时候没有static

/*成员变量（属性）：
String name;
int age;
成员方法（行为）：
public void eat(){}//吃饭
public void sleep(){}//睡觉
public void study(){}//学习
*/
public class Study{
String name;
int age;
public void eat(){
sout("吃饭饭")
}
public void sleep(){
sout("睡觉觉")
}
public void study(){
sout("学习")
}
}

//另一个页面调用方法public
包名称.方法名（）；

注意事项：

1.成员变量是直接写在类当中的，在方法外边

2.成员方法不要写static关键字

通常情况下，类不能直接使用，需要根据类创建一个对象，才能使用。

导包：也就是指出需要使用的类在什么位置。

import 包名称.类名称：

import cn.incast.day06.stuay:

对于和当前类属于同一个包的情况下，可以省略导包语句

创建，格式：

创建对象：类名称对象名=new 类名称（）；

Student student=new Student（）；

使用，分两种情况

使用成员变量：对象.成员变量名

使用成员方法：对象.成员方法名（参数）

也就是想用谁，就用对象名点谁

使用对象的成员方法格式;

对象名.成员方法名（）

注意事项：

如果成员变量没有进行赋值，那么将会返回一个默认值，规则和数组一样

//调用
//创建
Student stu=new Student();
sout(stu.name);//null
sout(stu.age);//0
//赋值
stu.name="赵丽颖"
stu.age=14;
sout(stu.name);//赵丽颖
sout(stu.age);//14

封装

alt+insert快捷键

1.封装可以提高程序的安全性，保护数据

2.隐藏代码的实现细节

3.统一接口

4.系统的可维护性

"高内聚，低耦合"

封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表现，而应该通过操作接口来访问，这成为信息隐藏。

属于私有：get/set

private ：私有

**get:获得这个数据**

**set：给这个数据设置值**

通常是对属性使用

//定义属性
private String name;//姓名
private int id;//学号
private char sex;//性别
//使用get/set
public String gerName(){
return this.name;
}
public void serName(int name){
this.name=name;
}
//调用get/set
Students S1=new Student（）；
S1.setName("111111")
sout(S1.getName());

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

extends的意思是"扩展"，子类是父类的扩展

Java中只有单继承，没有多继承

子类继承了父类，就会拥有父类所有方法

所有的类，都默认直接或者间接继承object类

public class Student extend teacher（）{
//有两个类，Student继承了teacher
}

super- this

privat私有的无法被继承

子类构造器默认调用父类构造器(必须在子类构造器的第一行)

子类可以调用父类的有参

super注意点：

super调用父类的构造方法，必须在构造方法的第一个

super必须只能出现在子类的方法或者构造方法中

super和this不能同时调用构造方法

Vs this：

1.代表的对象不同：

this：本身调用者的这个对象

super：代表父类对象的应用

2.前提：

this：没有继承也可以使用

super：只能在继承条件才可以使用

3.构造方法

this（）; 本类的构造器

super（）；父类的构造器

方法重写

父类的引用指向子类

Override重写

B b=new A();//父类的引用指向了子类，子类重写了父类的方法

静态方法和非静态区别很大

静态方法：方法调用之和左边，定义的数据类型有关

非静态：重写

重写：

需要有继承关系，子类重写父类的方法！执行子类的方法

方法名必须相同

参数列表必须相同

修饰符：范围可以扩大，单不能缩小：public>protected>Default>private

抛出的异常：范围可以被缩小，但不能扩大

重写，子类和父类必须一致，方法体不同！

为什么要重写：

父类的功能，子类不一定需要，或者不一定满足

ALT+Insert：override

多态

注意事项：

多态是方法的多态，属性没有多态

父类和子类，有联系类型转换异常！ClassCastException

存在条件：继承关系，方法需要重写，父类引用指向子类对象

不能重写的方法：

static方法属于类，不属于实例

final常量

private方法

子类可以调用自己的方法或着父类的方法

父类可以指向子类，但不能调用子类独有的方法

一个类的实际对象是确定的

instanceof

sout(X instanceof Y) XY有关系就为true

高转低强制转换

Student student=(Student)obj;
Student.go();
//写在一起为
((Student) obj).go();

父类引用指向子类对象

把子类转换为父类，向上转型

把父类转换为子类，向下转型，强制转换

方便方法的调用，减少重复的代码，简介

Stantic

静态变量使用：类名.变量

private static int age;//静态变量 private double score;//非静态变量 public static void main(String[] args) { Student s = new Student(); System.out.println(Student.age); System.out.println(s.score); System.out.println(s.age); } 静态方法：

非静态方法可以直接调用静态方法静态方法可以调用静态方法，不能调用非静态方法

public void run(){//非静态方法 go();//非静态方法可以直接调用静态方法 } public static void go(){//静态方法 }

{ System.out.println("匿名代码块")；//2号输出 } //静态代码块只执行一次，后面不执行 static{ System.out.println("静态代码块")//1号输出 } public Person(){ System.out.println("构造代码块")//3号输出 } public static void main(String[] ages){ Person person=new Person(); }
相关阅读:
【ARC机制和Java中C#中垃圾回收机制的区别构造方法里面必须用setter方法赋值 Objective-C语言】
算法与数据结构【30天】集训营——栈和队列的全套操作及易错知识点总结（07）
leetcode 63. 不同路径 II(dp)
leetcode(力扣) 491. 递增子序列（回溯 & 去重思路）
JVM 参数
 ES6 Class和Class继承
 【单片机毕业设计】【mcuclub-jj-004】基于单片机的楼道节能灯的设计
 worthington组织解离指南——上皮组织&结缔组织
 基于51单片机的人体红外震动检测家庭防盗报警器
 学习笔记14--机器学习在局部路径规划中的应用
原文地址：https://www.cnblogs.com/dzxi/p/16739532.html

ALT+Enter	导入包，自动修正代码
Ctr+y	删除光标所在行
Ctrl+D	复制光标所在行内容
Ctrl+ALT+L	格式化代码
ctrl+/	单行注释，再按取消注释

常量分类

使用变量时候 的注意事项：

创建变量：

数据类型转换

自动类型转换（隐式）

强制类型转换（显式）

注意事项：

运算符

1.算数运算符

加号'+'的三种用法：

自加自减

可以单独使用也可以混合使用

2.复制运算符

3.比较运算符

4.逻辑运算符

三元运算符

格式：

注意事项：

定义方法

定义方法的格式：

方法定义注意事项：

方法调用的格式：

判断语句1---if

第二种格式：if....elsed

第三章 选择语句

3.1选择语句---switch

第四章循环语句

循环的结构分为资格部分：

for循环

while循环语句

do-while循环

三种循环的区别

另一种循环控制语序continue关键字

idea常用快捷键

定义方法的完整格式：

方法的三种调用方法：

对比有参数和无参数

对比有返回值和无返回值

重载(Overload)

方法重载的基本使用方法

相关因素：

元素无关：

第四章循环语句

循环的结构分为资格部分：

for循环

while循环语句

do-while循环

三种循环的区别

另一种循环控制语序continue关键字

idea常用快捷键

定义方法的完整格式：

方法的三种调用方法：

对比有参数和无参数

对比有返回值和无返回值

重载(Overload)

方法重载的基本使用方法

相关因素：

元素无关：

数组

**数组的特点：**

数组的初始化：在内存中创建一个数组，并且向其中赋予一些默认值

常见的两种初始化方式：

动态初始化数组的格式：

数据类型 [] 数组名称 =new数据类型 [数组长度]

静态初始化基本格式：

静态初始化的省略格式：不能拆分为两个步骤

使用建议：如果不确定数组当中的具体内容，用动态初始化；否则用静态初始化

数组元素的访问

使用动态初始化的时候，其中的元素会自动拥有一个默认值：

Java的内存需要划分为5个部分

常见异常-空指针异常

获取数组长度：

数组一旦创建，程序运行期间，长度不可以改变，获取数组长度。

array.length：指的是输出数组当中每一个

数组遍历输出：对数组当中的每一个元素进行逐一输出

元素组的反转：其实就是对你的位置的元素交换

数组作为方法返回值，返回地址：

面向过程：

面向对象：

使用变量时候的注意事项：

第三章选择语句

数组的特点：