JavaSE笔记_驼峰定义法 java-CSDN博客

本文链接：https://blog.csdn.net/weixin_47882020/article/details/115617242

JDK:Java Development Kit

JRE:Java Runtime Environment

JVM: Java Virtual Machine

IDE:集成开发环境

数据类型

计算机中最小信息单元叫“位（bit）”，最小存储单位叫“字节（Byte）”。

1B（字节）=8bit

表示数据范围从小到大：byte–>short(char)–>int–long–float–double

97=a 65=A

变量

概述：

变量：在程序运行过程中，其值可以发生改变的量

使用

取值：变量名修改值：变量名=变量值（a=20）

定义变量：int a=10；

输出变量：system.out.println(a);

修改变量：a=20；

数字之间用下划线分割（方便观看，不影响数据）

使用注意事项：

在main 方法内，变量名不能重复。
一定要给变量赋值，不然就不能使用。
防止定义long类型时整数太大而被误会成Int类型，要在数值后面加上表示Long类型的L（long 1=10000000{报错}==>long 1=10000000L；{正确}。
定义float类型时，为了防止不兼容，要在后面加上F。和long类型相似。
实例变量如果不自行初始化，则是该类型的默认值

常量（Constant）

初始化之后不能改变值。一般使用大写字符。
final定义

//修饰符不存在先后顺序

标识符

标识符：就是给类，方法，变量等起名字的符号。

定义规则：

由数字，字母，下划线（_）和美元符（$）组成。
不能以数字开头。
不能是关键字。
区分大小写（在JAVA中大小写是很敏感的）。列如：class不能做标识符。但是Class可以。

常见命名约定

小驼峰命名法：方法和变量

标识符是一个单词的时候，首字母小写。–name
标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写。----firstName

大驼峰命名法：类

标识符是一个单词的时候，首字母大写。–Name
标识符是多个单词的时候每个首字母大写。–GoodName

类型转换

1.自动类型转换

把一个表示数据范围小的值或者变量赋值给另一个表示数据范围大的变量。

eg: double a=10（输出结果为10.0）

2.强制类型转换（可能造成数据的丢失）

把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。

格式：目标数据类型变量名=（目标数据类型）值或者变量

eg: int(k)=(int)88.88;(输出结果为88小数位舍去)

强制转换（类型）变量名高–低
自动转换低–高
（强制）类型转换时会出现内存溢出，或者精度问题

运算符

+：是运算符

a+b：是表达式

算述运算符

%（取余）取余得到的是余数。

幂运算：2^3 =2* 2* 2=8

整数相除只能得到整数，要想得到小数，必须有浮点数的参与。eg：6.0、

字符“+”操作

字符“+”操作是拿字符在计算机底层对应的数值来进行操作的。

‘A’----------->65 A-Z是连续的

‘a’----------->97 a-z是连续的

‘0’----------->48 0-9是连续的

算术表达式中包含多个基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。

提升规则：

byte类型，short类型和char类型将被提升到int类型
整个表达式的类型自动提升到表达式中最高等级操作作同样的数据的类型

等级顺序：byte,short,char–>int–>long–>float–>double

字符串的“+”操作

当“+”操作中出现字符串时，这个“+”是字符串连接，而不是算术运算。
```
String a="你好";
String b="神明";
System.out.print(a+b);
//运行结果：你好神明
```
在“+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算符。当连续进行“+”操作是从左到右执行。
```
int a=1;
int b=99
String c="神明与发光的少女";
System.out.print(a+b+c);
//100神明与发光的少女
System.out.print(c+b+a);
//神明与少女199
```
赋值运算符

int i=10; (把10赋值给int类型的变量a)

+=把左边和右边的数据做加法操作，结果赋值给左边
注意：扩展的赋值运算符底层隐含了强制类型转换

自增自减运算符

++ 自增：变量的值加1

– 自减：变量的值减1

单独使用是，++和–无论是放在变量的前边还是后边，结果是一样的。

i++ 先赋值后加 ++i 先加后赋值

关系运算符
== :a==b,判断a和b的值是否相等，成立为true，不成立为false.
！=：a！=b，判断a和b的值是否 不相等成立为。true，不成立为false
还有大于小于等…成立为true，不成立为false。
关系运算符的结果都是boolean类型。

逻辑运算符

逻辑运算符是用来连接关系表达式的运算符。
&逻辑与 (有假则假)
|逻辑或(有真则真)
^ 逻辑异或（同则假异则真）
！逻辑非（！false 为真！true 为假）

短路逻辑运算符

&& 作用和&相同，如果左边为假，右边不执行。

|| 作用和|相同，如果左边为真，右边不执行。

三元运算

格式：关系表达式？表达式1：表达式2；（如果表达式的关系为真则表达式1就是运算结果，如果是假表达式2就是运算结果。）

数据输入

Scanner的使用步骤

导包：import java.util.Scanner （导包的动作必须出现在类定义的上边）
创建对象：Scanner sc=new Scanner(System.in); (只有sc是变量名，可以变，其他的都不允许)
接受数据：int i=sc.nextInt(); (只有i是变量，可以变，其他的都不可以)
scanner.hasNext() 判断是否还有下一个
scanner.hasNextLine() 判断是否还有下一行
用完关闭，否则占用资源scanner.close();

流程控制

流程控制语句分类

顺序结构(没有特定语法结构，依次执行)
分支结构（if,switch）
循环结构(for,while,do……while)

if语句格式

格式1:
if (关系表达式) {
语句体:
}

执行流程:
1:首先计算关系表达式的值
2:如果关系表达式的值为true就执行语句体
3:如果关系表达式的值为false就不执行语句体
4:继续执行后面的语句内容

格式2:

if(表达式){

//表达式结果为true执行

}else{

//表达式结果为FLASE

}

格式3:

if(关系表达式){

//表达式结果为true执行

}else if(表达式2){

//表达式结果为true执行

}else if(表达式3){

//表达式结果为true执行

}else{

//以上表达式都不为true执行

}

switch

int a=1;
swicth (a){
    case'1':
    System.out.println("数字一");
    break;//没有break会穿透到下一行
    case'2':
    System.out.println("数字二");
    break;
    default:
    System.out.println("当上面没有匹配时输出")
}

循环

while

结构：while(布尔表达式){

//循环的内容

}

eg：计算1+2+3+……+100=？
    int i = 0；
    int sum =0；
    while(i<=100){
        sum =sum+i;
        i++;
    }
System.out.print(sum);
//测试结果为：5050

do while

do{

//代码语句

}while（布尔表达式）;

do while 和 while 相似不同的是，do while 循环至少会执行一次
whlie 和 do whlie 的区别
- while先判断后执行，do while 是先执行后判断

For循环

for (初始化；判断条件；迭代){

}

for(int i=0;i++;i<100){

System.out.println(i)//0-99

}

//练习：计算0-100的奇数和 偶数和
int jiSum=0;
int ouSum=0;
for(int i=0;i++;i<=100){
    if(i%2!=0){//奇数
        jiSum+=i;
    }else{//偶数
        ouSum+=i;
    }
}
	System.out.println("奇数和："+jiSum);
    System.out.println("偶数和:"+ouSum);
//运算结果
//奇数和：2500
//偶数和：2550

println 输出完会换行
print 输出完不会换行

//练习：用for循环输出1-1000之间能被5整除的数，并且每行输出3个
for(int i=0;i<=1000;i++){
    if(i%5==0){
        System.out.print(i+"\t");
    }
    if(i%(5*3==0)){//每行3个
        System.out.print("\n")
    }
}

//练习：打印九九乘法表
for(int j=1;j<=9;j++){
    for(int i=1;i<=j;i++){
        System.out.print(j+"*"+i+"="+(j*i)+"\t");
    }
    System.out.println();
}

增强for循环

for(声明语句：表达式){
//代码句子
}

int[] numbers={10,20,30,40,50};//数组
for(int x :numbers){
    System.out.println(x)
}
//10 20 30 40 50

break强制退出（跳出）循环
continue用于终止某次循环，跳过尚未执行的语句，接着进行下一次循环
return终止方法

//练习：打印五行的三角形
for(int i=1;i<=5;i++){
    for(int j=5;j>=1;j--){
        System.out.print(" ");
    }for(int j=1;j<=i;j++){
        System.out.rptin("*");
    }for(int j=1;j<i;j++){
          System.out.rptin("*");
    }
    System.out.println();
}

方法

main方法交于程序管理的。

一个方法只做一个功能（原子性）
格式

修饰符 返回值类型  方法名（参数类型 参数名){
    ……
    方法体
    ……
    return 返回值;
}

void 表示没有返回类型

存在返回值的情况下需要return

**形式参数：**在方法被调用时用于接收外界输入的数据（用来定义)

**实参：**调用方法时实际传给方法的数据(实际调用传递给他的参数)

方法的重载

在一个类中，有相同的函数名称，但形式参数不同放入函数。（方法名相同，形参类型不同）
重载的原则
- 方法名必须相同
- 参数列表必须不同（个数/类型/参数排列顺序……不同）
- 方法的返回值类型可以相同也可以不相同

递归

自己调用自己
结构
- 递归头：什么时候不调用自身方法。如果没有头，就会陷入死循环。
- 递归体：什么时候需要调用自身的方法。

补充点：阶乘

//2！ 2*1
//3! 3*2*1
//4! 4*3*2*1

边界条件

前阶段

返回阶段

因为java是栈机制，如果递归次数太多会大量积压，电脑承受不住。所以递归的次数不能太多。

数组

数组是相同数据类型的有序结合

变量的类型变量的名字 =变量的值；

创建数组的方法

new类型[容量]

//创建一个元素数量是10的int类型的数组
new int [10];

new 类型[ ]{元素}

//创建一个元素数量是3的String类型的数组，元素是aa.bb.cc
new String[]{"aa","bb","cc"};

创建并声明数组

String [] strs=new String[] {"aa","bb","cc"};

数组的索引是从0开始的。下标从0开始计算。
数组的长度：arrays.length
数组的最大的下标：arrays.length-1
下标的合法区间[0,length-1]越界就会报错
- ArrayIndexOutOfBoundsException:数组下标越界异常
打印数组元素Arrays.toString
对数组进行排序： Arrays.sort(数组) （升序

数组的基本特点

数组的长度都是固定的，不可以被改变
数组元素必须是相同类型，不允许出现混合类型
数组中的元素可以使任何数据类型，包括基本数据类型和引用类型
数组的变量属于引用类型，数组本身就是对象，数组中的每个元素相当于对象的成员变量。数组对象本身是在堆中。

注意：创建数组后，如果没有指定元素，则使用相应类型的默认值

内存分析

**堆：**存放new的对象和数组

可以被所有的线程共享，不会存放别的对象引用

**栈：**存放基本变量类型（会包含这个基本类型放入具体数值）

引用对象的变量（会存放这个引用在堆里面的具体地址）

**方法区：**可以被所有的线程共享

包含了所有的class和static变量

二维数组

int[][] array={{1,2},{2,3},{3,4},{4,5}};

冒泡排序

在比较数组中，两个相邻的元素，小的排在前面。

public class ArrayDemo01{
    public static void main(String[] args){
        int[] a={1,2,3,4,5,43,16,30,29};
        int[] sort=sort(a);//调用自己写的排序方法，返回一个排序后的数组
        System.out.println(Arrays.toString(sort));
  	    }
        public static int[] sort(int[] arry){
            //临时变量
         	int temp=0;
   			//外层循环，判断我们要遍历几次
            for(int i=0;i<array.length-1;i++){
                boolean flag=flase;//减少不必要的比较
                //内循环，两个数进行比较。
                for(int j=0;j<arry.length-1-i;j++){
                    if(array[j+i]<array[j]){
                      temp=array[j];
                      array[j]=array[j+i];
                      array[j+i]=temp;
                }
            }
                if (flag==flase){
                    break;
             }
        }
             return array;
    }
}

面向对象编程

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

类是一种抽象的数据类型，他是对某一类事务整体描述/定义，但并不能代表某一个具体的事务。
对象是抽象概念的具体实例
三大特性
- 多态
- 封装
- 继承

封装

属于私有get/set

1.提高程序安全性，保护数据。

2.隐藏代码实现细节

3.统一接口

4.增加系统可维护性

继承

java中只有单继承，没有多继承。

extends“扩展”，子类（派生类）是父类（基类）的扩展。

继承是类和类之间的关系。

super

调用父类的构造方法，必须在构造方法的第一个。
必须只能出现在子类的方法或者构造方法中
super和this不能同时调用构造方法
super和this的区别
- 代表对象不同
  - this:本身调用这个对象
  - super：代表父类对象的应用
- 前提不同
  - this：没有继承也可以使用
  - super：只能在继承条件用中使用
- 构造方法
  - this（）：本类的构造
  - super（）：父类的构造

重写

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

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

1.方法名必须相同

2.参数列表列表必须相同

3.修饰符：范围可以扩大但不能缩小

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

重写。子类的方法和父类必须要一致，方法体不同。
子类重写了父类的方法，执行子类的方法
修饰符的范围
- public>protected>default>private

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型时确定的，但可以指向对象的引用的类型有很多种

多态是方法的多态，属性没有多态
父类和子类，有联系否则出现类型转换异常
存在条件：继承关系方法需要重写，父类引用指向子类对象

类型转换

父类引用指向之类的对象
把子类转换为父类，向上转换：自动转换
把父类转为子类，向下转换：强制转换
方便方法的调用，介绍重复代码。简洁。

Static静态的

静态代码块比匿名代码块和构造方法先执行。

抽象类abstract

抽象方法，只有方法名，没有方法的实现。

抽象类的所有方法都由他的子类去实现。

约束：不能new这个抽象类，只能靠子类去实现它。

抽象类里可以写普通的方法

抽象方法必须在抽象类中

接口

普通类：只能实现

抽象类：具体实现和规范（抽象方法）都有。

接口：只有规范，自己无法写方法，专业的约束，约束和实现分离。

接口中所有的定义都是抽象的。
接口实现了多实现

作用

约束
定义一些方法给不同的人实现
pubic abstract
接口不能实例化，接口中没有构造方法
可以实现多个接口
必须重写接口中的方法

内部类

内部类就是在一个类的内部定义一个类，比如在A类中定义一个B类，那么B类相对于A类来说就称为内部类。而A类对于B类来说就是外部类。

public class Outer{
    private int id;
    Public void out(){
        System.out.print("这是外部类方法");
    }
    public class Inner{
        public void in(){
            System.out.print("这是内部类方法");
        }
        //获得外部类的私有属性
        public void getId(){
            System.out.print(id);
        }
    }
}

1.成员内部类

要调用内部类的话，要先调用外部类，再通过这个外部类来实例化内部类。（以上面的代码为列子）
内部类可以获得外部类的私有属性，私有方法

Outer outer =new Outer();

Outer.Inner inner=outer.new Inner();

inner.in();

inner.getID();

2.静态内部类

public class Outer{
    private int id;
    Public void out(){
        System.out.print("这是外部类方法");
    }
    public static class Inner{
        public void in(){
            System.out.print("这是内部类方法");
        }
    }
}

无法获得外部类的私有属性

3.局部内部类

在方法里面写的类

public void method(){
	class Inner{
		punlic void in(){
		}
	}
}

4.匿名内部类

class A{
    
}

一个java类中可以有多个class类，但是只能有一个public calss
不用将实例保存到变量中 new Apple().eat(); 直接调用方法，没有名字的初始化类

异常Exception

java常把异常当做对象处理，并定义一个基类java.lang.Throwable作为所有异常的超类

1.Exception异常

检查性异常
运行时异常RuntimeException
- ArrayIndexOutOfBoundsException数组下标越界
- NullPointerException空指针异常
- ArithmeticException算术异常
- MissingResourceException丢失资源
- ClassNotFoundException找不到类
- 这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

2.Error错误

Error类对象由java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
Error发生时JVM一般会选择线程终止。

异常处理机制

关键字：try catch finally throw throws

抛出异常

throw:（手动）主动抛出异常，一般在方法中使用。

throws：方法抛出异常

捕获异常

try{
    //监控区域
}catch(异常类型 e){
    //捕获异常
    e.printStackTrace();//打印错误的栈信息
}catch(){
    //可以有多个catch
}finally{
    //异常处理后必须执行
    //可以不要
    //通常用于处理IO 资源关闭
}