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

第四章循环语句

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

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

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

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

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

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数字相加的方法。三要素：

  1. 返回值类型：int

  2. 方法名称：sum

  3. 参数列表：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;//返回值
 }
方法的三种调用方法：

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

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

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

 

 

对比有参数和无参数

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

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

对比有返回值和无返回值

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

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

 {//有返回值的调用
     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

 

第四章循环语句

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

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

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

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

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

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数字相加的方法。三要素：

  1. 返回值类型：int

  2. 方法名称：sum

  3. 参数列表：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;//返回值
 }
方法的三种调用方法：

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

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

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

 

 

对比有参数和无参数

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

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

对比有返回值和无返回值

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

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

 {//有返回值的调用
     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;
 }

相关因素：

  • 参数个数不同

  • 参数类型不同

  • 参数的多类型顺序不同

元素无关：

  • 与参数的名称无关

  • 与方法的返回值类型无关

数组

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

**数组的特点：**

  • 数组是一种引用数据类型

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

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

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

  1. 静态初始化（指定内容）

  2. 动态初始化（指定长度）

动态初始化数组的格式：
数据类型 [] 数组名称 =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位置

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

  1. 整数类型：默认值为0

  2. 浮点类型：默认值为0.0

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

  4. 布尔类型：默认值为false

  5. 引用类型：默认值为null

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

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

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

方法运行一定要在栈当中

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

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

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

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

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

  1. 整数类型：默认值为0

  2. 浮点类型：默认值为0.0

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

  4. 布尔类型：默认值为false

  5. 引用类型：默认值为null

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

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

  8. 寄存器（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（）{}
 //构造器 
 //无参构造
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：

  1. 必须和类的名字相同

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

构造器得到作用：

可以实例化初始值

核心作用：

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

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

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

有参构造：

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

 public Person(String name){
 this.name=name;
 }
注意点：定义一个有参构造之后，如果想要使用无参构造，显示的定义一个无参构造

this.当前类=

构造器

alt+insert：快捷生产构造器

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

无参构造：

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

  1. 必须和类的名字相同

  2. 必须没有返回值类型，也不能写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();//父类的引用指向了子类，子类重写了父类的方法

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

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

非静态：重写

重写：

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

  1. 方法名必须相同

  2. 参数列表必须相同

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

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

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

为什么要重写：

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

ALT+Insert：override

多态

注意事项：

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

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

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

 

不能重写的方法：

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

  • final常量

  • private方法

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

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

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

instanceof

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

高转低强制转换

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

  1. 父类引用指向子类对象

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

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

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

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();
}
 
posted @   不会小小  阅读(65)  评论(0)  编辑  收藏  举报
相关博文：
·  java 基础
·  Java 基础语法
·  黑马javase跟学笔记
·  代码审计——基础（JAVASE）
·  2.Java语法基础
阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列01：轻松3步本地部署deepseek，普通电脑可用
· 25岁的心里话
· 按钮权限的设计及实现
点击右上角即可分享
微信分享提示
AI IDE Trae