java基础

Alanna_Rem

于 2021-08-12 18:19:38 发布

阅读量114

点赞数

本文链接：https://blog.csdn.net/weixin_44297915/article/details/119650854

版权

Java

Java特性和优势

简单性
面向对象
可移植性

Write once，Run anywhere

由于Java是解释性语言，编译器会将Java代码变成“中间代码”，然后在Java虚拟机(Java Virtual Machine，JVM)上解释执行。由于中间代码与平台无关，因此Java语言可以很好的跨平台执行，具有很好的可移植性。
高性能
分布式
动态性

反射
多线程
安全性

Java不支持指针，一切对内存的访问都必须通过对象的实例变量来实现
健壮性

Java三大版本

JavaSE：标准版（桌面程序，控制台开发）
JavaME：嵌入式开发（手机，小家电）近乎灭绝。。。
JavaEE：企业级开发（web开发，服务器开发）

JDK、JRE、JVM

JDK:

（ Java Develpment Kit ）java开发工具
JRE：

（Java Runtime Environment java）运行时环境
JVM：

（Java Virtual Machine） java 虚拟机

jdk，jre，jvm

jdk2

Java程序的运行机制

解释型语言

更倾向于操作系统 C C++

编译型语言

更倾向于网页 web JavaScript

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uxZskVPD-1628763518487)(C:\Users\半城烟雨半城殇\Desktop\blog图片\java运行机制.png)]

Java命名规范

一、命名规范

1、项目名全部小写

2、包名全部小写

3、类名首字母大写，如果类名由多个单词组成，每个单词的首字母都要大写。

如：public class OneJavaClass{}

4、变量名、方法名首字母小写，如果名称由多个单词组成，除了首字母单词都要大写。驼峰命名原则，首字母小写和驼峰原则：myMomey 出第一个单词以外后面的单词首字母大写 lastTime。

如：int index=0;

public void userName(){}

5、常量名全部大写,多个单词用下划线_隔开

如：public static final String GAME_COLOR=”RED”;

6、所有命名规则必须遵循以下规则：

1)、名称只能由字母、数字、下划线、$符号组成

2)、不能以数字开头

3)、名称不能使用JAVA中的关键字。

4)、坚决不允许出现中文及拼音命名

数据类型

强类型语言

要求变量的使用严格符合规定，所有变相都必须先定义才能使用。如果不经过转换就永远是这个类型。java C++
安全性高速度慢一点

弱类型语言

不一定要严格符合规定 JavaScript

Java数据类型

基本类型

数值类型

整数类型：

byte占1个字节、8位、范围：-128—127、-2^7-27-1

short占2个字节、16位、范围：-2^15 - 2^15-1

int占4个字节、32位、范围：-2^31 - 2^31-1

long占8个字节、64位、范围：-2^63 - 2^63-1

long类型要在后面加个L long num = 30L；
浮点类型

float占4个字节、32位

float类型要在后面加个F long num = 30.0F；

double占8个字节、64位
字符串类型char占2个字节、16位

Boolean类型：

占1位其值只有true和false两个

引用类型

类、接口、数组

字节

位（bit)：是计算机内部数据存储的最小单位，11001100是一个八位二进制数
字节（byte）：是计算机中数据处理的基本单位，一般用B表示
1B（字节 byte）= 8bit（位）
字符是指计算机中使用的字母、数字、字和符号

1bit表示1位

1Byte表示一个字节1B=8b

1024B=1KB 1024KB=1M

类型转换

由于Java是强类型语言所以计算的时候要先转化为同一个类型再进行运算

低-------------------------------------------------------->高

byte,short,char-> int ->long -> float->double

int i = 128;
byte b = (byte)i;	//b=-128 内存溢出
double c = i;   //c=128.0
//强制转换	(类型)变量名   高--低
//自动转换  低--高
/*  1.不能对布尔类型进行转换
	2.不能把对象类型转为不相干的类型
	3.在把高容量转换到低容量的时候，强制转换
	4.转换过程可能出现内存溢出，或者损失精度问题
*/
System.out.println((int)23.7);//23
System.out.println((int)-45.33f);//-45

//操作数比较大的时候要注意溢出
//JDK7新特性，数字之间可以用下划线分割
int money =10_0000_0000;
int years = 20;
int total = momey * years;//-1474836480,计算的时候内存溢出
long total2 = momey * years;//默认是int，转换之前就出现问题，先计算再转换再赋值
long total3 = momey *((long)years);//先把一个转换为long类型
System.out.println(total3);//200e

运算符

int a = 1;
int b = a++;	//b=3  先给b赋值 再自增
int c = ++a;	//c=5    先自增   再给b赋值

很多运算都会使用工具类来操作

比如说幂次方运算 pow

逻辑运算符

//与（and） 或（or） 非（取反）
boolean a = true;
boolean b = false;

System.out.println("a && b");//false 逻辑与运算：两个变量都为真，结果才为true
System.out.println("a || b");//true	逻辑或运算：两个变量有一个真，结果才为true
System.out.println("!(a && b)");//true 如果是真 则变为假 假则变为真

//短路运算
int c = 5;
boolean d = (c<4)&&(c++<4);    //左边是错的右边就不执行
System.out.println(d);//d=false
System.out.println(c);//c=5

位运算

A = 0011 1100

B = 0000 1101

A&B 0000 1100 //如果两个都为1，则为1,否则为0

A|B 0011 1101 //有一个为1则为1，否则为0

A^B 0011 0001 //两个相同为0，否则为1

~B 1111 0010 //取反

二进制的位运算效率极高

*左移 << 2

右移 >> /2

a += b; //a = a+b

a -= b; //a = a-b

字符串连接符 + ，String

int a =10;
int b =20;
System.out.println(""+a+b);//1020
System.out.println(a+b+"");//30
//字符串在前面则全部转换为String类型
//如果在后面则不影响前面的

三元运算符

public static void main(String[] args){
	// x ? y : z
    //如果x==true 则结果为y  否则结果为z
    
    int score = 80;
    String type = score <60 ? "不及格":"及格";
}

java中运算符的优先级

优先级记忆方法：单目乘除为关系，逻辑三目后赋值。（前辈总结的）

单目运算符:一次作用一个变量的运算符，又叫一元运算符
单目：单目运算符+ –(正负数) ，++ –，！（逻辑非），~（按位取反）
乘除：算数运算符：* / % + - （* / %优先级肯定是大于±的）
为：位运算符：~（按位取反）<<(左移) >>(右移)，^（也可以位运算，二进制异或）
关系：关系运算符：> < >= <= == !=
逻辑：逻辑运算符（除！）&& || & | ^
三目：条件运算符A > B ? X : Y
后：无意义，仅仅为了凑字数
赋值：= += -= *= /= %= |= &= ^=
说明：前优先级大于后，比如单目运算符_{也是位运算符，}的优先级是单目级别的。

Scanner对象

scanner.next();
- 输入有效字符后将其后面的空白作为结束符号
- 不能得到带有空格的字符串
scanner.nextline();
- 以enter为结束符
- 可以获得空白

//从键盘接收数据
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据：");
String str = scanner.nextline();
System.out.println(str);
scanner.close();//关闭流 节省资源

循环

while 和do while区别

while先判断后执行，dowhile是先执行后判断
dowhile总会保证循环体至少执行一次。主要区别！

For循环

for循环是支持迭代的一种通用结构，是最有效、最灵活的循环结构

for循环执行的次数是在执行前就确定了。语法格式如下：

for(初始化;布尔表达式；迭代){
    //代码
 }
//ideaj 快捷方式100.for

99乘法表

public class ForDemo03 {
    //99乘法表
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print( i +"*" +j +"="+ i*j +"\t");
            }
            System.out.println();
        }
    }
}

增强for循环

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

break:直接退出循环不执行循环剩下的语句
continue：终止某次循环，接着进行执行下一句循环

Java方法

方法的原子性，一个方法值完成一个功能
```
修饰符  返回类型  方法名（参数类型 参数名）{
	方法体
	return	返回值;
}
```
形式参数：是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数。？

实际参数：在调用有参函数时，主调函数和被调函数之间有数据传递关系。在主调函数中调用一个函数时，函数名后面括号中的参数称为“实际参数”。
值传递（pass by value）是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递（pass by reference）是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。指向对象本身。

重载

重载就是一个类中，有相同的函数名称，但是形参不同的函数

重载的规则

方法名称必须相同
参数列表必须不通（个数，类型，参数的排列顺序不通等）
方法的返回类型也可以不一样
仅仅返回类型不应不构成重载

public static  double max(double num1,double num2){
    double result  = 0;
    return result;
}
public static int max(int num1,int num2){
    int result  = 0;
    return result;
}
public static int max(int num1,int num2,int num3){
    int result  = 0;
    return result;
}

递归

方法调用方法本身

递归结构包括：

递归头：什么时候不调用自己方法。如果没有，就陷入死循环（边界条件）
递归体：什么时候需要调用自身方法

数组

数组是相同类型数据的有序结合
每一个数据称作数组元素，都有一个下标
数组长度是确定的，一旦创建就不可以改变大小
数组的元素必须是相同类型，不能混合，可以使任意数据类型（基本类型和引用类型）
数组本身是在堆中的
数组也是对象

public static void main(String[] args) {
        int[] nums; //声明一个数组
        int  arr[]; //不建议使用这种方法

        nums = new int[10];
    
    	int[] arr2 =new int[10];
        nums[0] =1;
        nums[1] =2;
        nums[2] =3;
        nums[3] =4;
        nums[4] =5;
        nums[5] =6;
        nums[6] =7;
        nums[7] =8;
        nums[8] =9;
        nums[9] =10;

        int sum = 0;
        for (int i = 0; i <nums.length ; i++) {
                sum = sum + nums[i];     
        }
        System.out.println(sum);//sum=55
    }

内存

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

可以被所有的线程共享，不会存放别的对象引用
栈：存放基本变量类型（包含这个基本类型的具体数值）

引用对象的变量（存放这个引用堆里面的具体地址）
方法区：可以被所有线程共享

包含所有的class和static变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XYD4dJZ3-1628763518490)(C:\Users\半城烟雨半城殇\AppData\Roaming\Typora\typora-user-images\image-20210808164732727.png)]

静态初始化：创建+赋值

int[] a = {1,2,3,4,5};
System.out.println(a[0]);

动态初始化：后期手动赋值包含默认初始化

int[] b = new int[10];
b[0] = 1;

数组的默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一旦分配空间，其中的每个元素也被按照市里变量同样的方式被隐式初始化。

多维数组

多维数组可以看成数组的数组，如二维数组里的每一个元素都是一个一维数组。

创建一个二维数组

int a[][] = new int[2][5];
int b[][] = {{1,2},{2,2},{3,3}};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qMHy4WxK-1628763518494)(C:\Users\半城烟雨半城殇\AppData\Roaming\Typora\typora-user-images\image-20210808180634816.png)]

Arrays类

打印数组：Arrays.toString(arr);
升序排序：Arrays.sort(arr);

八大排序之冒泡排序：

比较两个相邻的数，如果第一个比第二个大则交换位置

每次比较都会产生一个最大或者最小的数

下一轮则可以少一次排序

public static void main(String[] args) {
        // 新建一个数组
        int[] a = {2,2,3,4,5,6,142,56213,41,2};
        //数组调用方法
        int[] sort= sort(a);
        System.out.println(Arrays.toString(sort));
    }

    public static int[] sort(int[] array){
        //新建临时变量
        int temp = 0;
        //外层循环判断要走多少次
        for (int i = 0; i < array.length-1 ; i++) {
            //添加一个标识符减少没必要的比较
            boolean flag = false;

            //内层循环 第一个数比第二个数大则换位
            for (int j = 0; j < array.length-1 ; j++) {
                if(array[j]>array[j+1]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            if (flag== false){
                break;
            }
        }
        return  array;
    }

nt temp = 0;
//外层循环判断要走多少次
for (int i = 0; i < array.length-1 ; i++) {
//添加一个标识符减少没必要的比较
boolean flag = false;

        //内层循环 第一个数比第二个数大则换位
        for (int j = 0; j < array.length-1 ; j++) {
            if(array[j]>array[j+1]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
                flag = true;
            }
        }
        if (flag== false){
            break;
        }
    }
    return  array;
}

Alanna_Rem

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础

JavaJava特性和优势简单性面向对象可移植性Write once，Run anywhere由于Java是解释性语言，编译器会将Java代码变成“中间代码”，然后在Java虚拟机(Java Virtual Machine，JVM)上解释执行。由于中间代码与平台无关，因此Java语言可以很好的跨平台执行，具有很好的可移植性。高性能分布式动态性反射多线程安全性Java不支持指针，一切对内存的访问都必须通过对象的实例变量来实现健壮性Java三
复制链接

扫一扫