JAVA基础

JAVA基础 注释

// 单行注释

标识符

1. 所有的标识符都应该以字母（A-Z 或 a-z），美元符($)，或者下划线开头(_)开头

2. 首字符之后可以是任意字符

3. 不能使用关键字作为变量名或方法名

4. 标识符是大小写敏感的

数据类型 强类型语言

变量必须先定义后才能使用

弱类型语言 基本类型语言(primitive type )

1. 整型： byte ： 1字节 -128 ~ +127

   ​ short ： 2字节

   ​ int ： 4字节

   ​ long ： 8字节

2. 浮点型 ： float ： 4字节

   ​ double ： 8字节

3. 字符型 char 2字节

4. Boolean 类型 ： 1位（True / false）

引用类型（reference type）

类

接口

数组

整数拓展

进制 二进制 ob 十进制 八进制 0 十六进制 0x

浮点数拓展

最好完全使用浮点数比较

银行业务表示： BigDecimal类 （数学工具类）

字符拓展

所有字符本质还是数字，

字符可以使用强制转换，转换为对应的字符编码（unicode）.

布尔类型拓展

boolean flag = true;

if(flag){} <=====> if(flag == true) {};

转义字符

t	制表符
n	换行符

类型转换

小数的优先级大于整数

byte ， short ，char ， —> int —> long ----> float ------> double

运算中,不同类型的数据先转化为同一类型的数据强制转换 (类型)变量名 高------> 底

自动转换 底------>高

 int i = 128;  // 128
        byte b = (byte) i;//内存溢出 -128
        System.out.println(i);
        System.out.println(b);

注意点:

1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 把高容量转为低容量时，强制转换
4. 转换时可能存在内存溢出 或者 精度问题

变量

(内存中的一块空间)变量必须先申明再使用

Java是一种强类型语言，每个变量都必须声明类型

Java变量是程序中最基本的单元，其要素包括变量名 ，变量类型和作用域。

注意：

1. ​ 每个变量都有类型，类型可以是基本类型，也可以是引用类型

2. 变量名必须是合法的标识符

3. 变量申明是一个完整的语句，因此每个声明都必须以分号结束

   变量的作用域

   局部变量：必须先申明和赋值 在方法里面

   实例变量：从属于对象，如果不初始化则赋默认值

   类变量：static 变量类型 变量名；

常量

final 常量名 = 值；

常量名一般是大写

变量命名规范

1. 所有变量，方法，类名：见名知意思
2. 类成员变量：首字母小写和驼峰原则： monthSalary 除了第一个单词以外，后面的首字母大写 lastName
3. 局部变量： 首字母小写和驼峰原则、
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则：Man ， GoodMan
6. 方法名： 首字母小写和驼峰原则：run() , runRun()

运算符

1. 算术运算符 : +，-，*，/，%（模运算），++（在前先自增，再赋值），–

2. 赋值运算符 : =

3. 关系运算符 : >，< , >= , <= , == , != , instanceof

4. 逻辑运算符: &&（与） , ||（或） , !（非，取反）

5. 位运算符 : & , |, ^, ~, >>, <<

6. 条件运算符：？：

    int score = 50;
           String type = score < 60 ?"不及格":"及格";
           System.out.println(type);//不及格
   

7. 字符串连接符

   System.out.println(" "+c+d); // 1020
           System.out.println(c+d+" ");//30 
   

包机制

为了更好的组织类，Java提供了包机制，用于区别类的命名空间

一般利用公司域名倒置

import 语句可以导包

JavaDoc 文档

用来生成自己的API文档

参数信息：

​ @author 作者名

​ @version 版本号

​ @since 指明需要最早使用的jdk版本

​ @param 参数名

​ @return 返回值情况

​ @throws 抛出异常情况

Scanner类 基础语法

Scanner   变量名  = new  Scanner(System.in);

变量.close()

通过Scanner类的next() 和 nextLine() 方法获取输入的字符串，再读取前通常使用hasNext() 和 hasNextLine() 判断是否还有输入的字符

注意：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CDmm5AtK-1651149793931)(E:2022.4.26 javaJava博客JAVA基础scanner.png)]

1. next() 以空的结束，不能输入带空格的字符
2. nextLine() 以enter结束，可以获得空白

基本流程结构 顺序结构

由上向下运行，它是任何一个算法都离不开的基本算法结构

选择结构

if 单选择结构 if(表达式){ }

if 双选择结构 if(表达式){ }else { }

if 多选择结构 if（表达式）{ } else if （表达式） { } else if（表达式）{ }

Switch（）多选择结构

​ switch case : 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支

switch( ) 语句中的类型可以是：

​ byte，short，int ， char， String

循环结构

1. while循环

​ while（布尔表达式）{ }

大多数情况会让循环停止下来的，写一个让表达式失效的方式结束循环

避免死循环

2. do …while 循环 至少执行一次

3. For 循环（外层控制行数，内层控制列数）

​ for（初始化；布尔表达式；更新）{

​ }

4. 增强for循环

   for （声明语句：表达式）{ }

   声明语句：声明新的局部变量。该变量的类型必须和数组元素的类型匹配，其作用局限在循环语句块，其值与此时数组元素的值相等。

   表达式：表达式是要访问的数组名，或者是返回值为数组的方法

break 与continue

其后不能加其他语句

break强制推出循环

continue结束某次循环

带标签的break 与 continue

label ： for（ ）{

for( ){ break label ; } }

方法

（首字母小写，驼峰原则）

Java方法是语句的集合，它们在一起执行一个功能

方法是解决一类问题的步骤的有序集合

方法包含于类和对象中

方法在程序中被创建，在其他地方被引用

静态方法

public static 修饰

可以使用：类名.方法名调用 （和类一起加载）

非静态方法

public 修饰

使用：实例化这个类 new

​ 对象类型 对象名 = 对象值；

​ 实例化后才存在

格式  
    修饰符    返回值类型    方法名（参数类型   参数名）{
    
    }


方法调用
     对象名.方法名(参数列表)    （new 一个对象）
    
     当方法返回一个值的时候，方法调用通常被当作一个值
    eg: int  larger = max(30,40);

方法重载

在同一个类中，有相同的函数名称，但形参不同的函数

方法重载的规则：

	1. 方法名必须相同
	2. 参数列表不同（个数不同，或类型不同，参数排列顺序不同）
	3. 方法的返回值类型可以相同，可以不同
	4. 仅仅返回值类型不同不足以成为方法的重载

可变参数

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

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

递归

A方法调用A方法

递归结构包括两个部分：

​ 递归头：什么时候不调用自己的方法，如果没用递归头，将陷入死循环

​ 递归体：什么时候需要调用自己的方法

能不使用递归就不使用

数组

1. 数组是相同类型的有序集合

2. 数组描述的是相同类型的若干个数据，按照一定的先后排列顺序组合而成

3. 每个数组作为一个数组元素，通过下标访问（从0开始）

   //变量类型   变量的名字   = 变量值
           //数组类型
           int[] array;//1.声明一个数组
           array = new int[10]; //2.创建一数组
   
           //3.给数组中赋值
           array[0] = 1;
           array[1] = 2;
           array[2] = 3;
           array[3] = 4;
           array[4] = 5;
           array[5] = 6;
           array[6] = 7;
           array[7] = 8;
           array[8] = 9;
           array[9] = 10;
   
           System.out.println(array[2]);//4.取值
           //计算所有数的和
           int sum =0;
           for (int i = 0; i < array.length; i++) {
               sum+=array[i];
           }
           System.out.println("总和为:"+sum);
       }
   
   
   
      int[] array = new int[10];//动态初始化    被隐式初始化，默认值：0
           int[] array01 = {10, 20, 30, 40, 50, 60, 70, 80, 90};//静态初始化，创建+赋值
           String[] name = {"张三", "李四", "王五"};
   //    增强型for循环遍历数组
   //        for (int value : array01
   //        ) {
   //            System.out.println(array01[2]);
   //            System.out.println(array01);//返回元素地址
   //        }
   

   Arrays类

   方法名	使用方法	返回值
   equals(array1,array2 )	比较两个数组是否相等	返回Boolean类型
   sort(array)	对array的元素升序排列	返回值为void
   toString(array)	将一个数组array转换成字符串	返回String类型
   fill(array,value)	把数组所有的元素都赋值成value	返回值为void

   冒泡排序

     int[] array01 = {20, 15, 98, 45, 62, 15, 45, 78, 65, 12, 32, 174, 45};//静态初始化，创建+赋值
           //比较数组中两个相邻的元素，如果第一个比第二个大就交换位置
           //每次比较产生一个最大或最小的数
           //依次排序,直到结束
           int[] array=sort(array01);
           System.out.println(Arrays.toString(array));
       }
   
       public static int[] sort(int[] a) {
           int temper = 0;
           //外层循环,判断走多少次
           for (int i = 0; i < a.length-1; i++) {
               //判断两个数字的大小
               for (int j = 0; j < a.length - 1 - i; j++) {
                   if (a[j + 1] > a[j]) {
                       temper = a[j ];
                       a[j] = a[j+1];
                       a[j+1] =temper;
                   }
               }
           }
           return a;
   

---

面向对象

物以类聚，分类的思维模式

对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统，但是具体到围观操作，任然需要面向过程的思路方法处理。

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

抽象

三大特征：封装，继承，多态

对象：是该类事物的具体表现，是一种具体存在

类：一系列具有相同属性和行为的事物的统称，是一个抽象的概念

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

使用new关键字创建对象

使用new关键字创建对象的时候，除了分配内存空间之外，还会给创好的对象进行默认的初始化，以及对其类中的构造器的调用

构造器

和类名相同，没用返回值

作用：

1. new 本质在调用构造方法（创建对象）
2. 初始化对象的值
3. 有参构造，在实例化对象的时传递参数
4. 默认构造器的权限和类的权限相同

注意点：

1. 有有参构造时必须显示无参构造
2. 快捷键 ALT +Insert
3. 在一个包内，只允许一个类是公共类（public），可以没用公共类

封装

数据的隐藏，属性私有

程序设计追求“高内聚，低耦合”

高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉

低耦合：仅暴露少量的方法给外部使用

属性私有 使用get / set 方法 private set方法可以设置安全性判断

get获得属性，set给属性赋值

好处：

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 增加系统的可维护性

权限修饰符

–	类内部	同一个包	不同包的子类	同一个工程
private	√
缺省	√	√
protected	√	√	√
public	√	√	√	√

继承

多个类种存在相同的属性和行为 ，只有单继承

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

格式
	修饰符    class    子类  extends 父类{
	
	}

子类继承了父类，就会拥有父类的所有非私有成员，私有属性不能直接调

在java种，所有的类，都默认之间或间接的继承Object类

super 注意点：

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

2. super必须只能出现在子类方法或构造器中

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

   VS

   this 代表的对象不同

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

   ​ super 代表父类对象的引用

​ 前提：

​ this 没有继承也可以使用

​ super只能在继承下才能使用

构造方法

​ this(); //本类的构造

​ super(); //父类的构造

重写

必须是非static的方法，子父类之间的同名方法，子类重写父类的方法

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符范围可以扩大
4. 抛出异常，范围可以缩小，但不能扩大
5. 子类的方法和父类的方法必须一致，方法体不同
6. 父类的功能，子类不一定需要或者不一定满足

多态

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

父类和子类，有联系

存在条件：继承关系，有方法重写，父类引用指向子类对象 Father f = new Son（）;

不能重写的方法：

1. static方法，属于类，它不属于实例
2. final 常量
3. private 方法

向上转型，子类向父类的转换

<父类名> <引用变量> = new <子类名> Father f = new Son（）;

特点：

1. 减少类中的代码量
2. 提高代码的可扩展性和可维护性

使用场景：父类可以作为形参的数据类型，这样可以接收其任意类型的子类对象

多态关系中，成员变量是不涉及重写的，使用成员变量，遵守“编译看左，运行看右”

instanceof

返回布尔类型，X(引用对象) instanceof Y(类型) ，X与Y之间必须有继承关系，否则会出现编译错误

类型转换：

​ 把子类转换为父类，向上转型，不用强制转换

​ 把父类转换为子类，向下转型，强制转换，可能丢失方法无法调用子类的特有方法

​ （类型）变量名;

static

修饰成员变量能被本类的所有对象共享

public     static     final    公共的静态常量修饰符
    静态方法与类一起加载，只执行一次

final

修饰常量 ，修饰的类不能被继承 修饰的方法不能被重写

异常（exception）

检查性异常：具有代表性的检查性异常是用户或问题引用的异常，这是程序员无法预见的

运行时异常： 运行时异常可能是可能被程序员避免的异常

错误Error： 错误不是异常 错误可以避免

在Exception分支中有一个重要的子类RuntimeException（运行时异常）

异常处理机制
	抛出异常
	捕获异常
	try{
	//控制区域
	}catch(捕获异常类型){
	//捕获异常，捕获多个异常时由小到大
	}fianlly{
	//不管有没有异常都会执行。可以不要   一般方法关闭操作
	}
	
	快捷键： 选中当前语句 + ctrl + T

throw 抛出异常 一般会在方法中使用，可以作为单独语句使用

throws 必须是跟在方法参数列表的后面，不能单独使用

实际应用中的经验总结：

1. 处理运行时异常时，采用逻辑去合理的规避同时辅助try-catch处理
1. 在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
1. 对于不确定的代码，也可以加上try-catch 处理潜在的异常
1. 尽量去处理异常，切忌只简单的调用printStackTrace（）去打印输出
1. 具体如何处理异常，要根据具体的业务需求和异常类型去决定
1. 尽量使用finall语句块去释放占用的资源