投稿
  1. 首页
  2. java

Java基础语法

code • 2022-5-6 • java • 阅读 24

Java基础语法,第1张

目录

计算机存储单元

进制

数据类型

基本数据类型

引用数据类型

强制类型转换

常量

final修饰的

变量

运算符

算数运算符+，-，*，/，%，++，--

关系运算符

逻辑运算符& | ! ^ &&（短路与） ||（短路或）

三目运算符

赋值运算符

条件与循环语句

选择结构if

switch

while

do...while

for循环

break和continue

嵌套循环

数组

数组的遍历

数组的特点

数组的优缺点

优点

缺点

foreach的底层

检索速度快

数组拷贝及扩容

数组工具类Arrays

二维数组

算法

数值交换

冒泡排序

选择排序

二分查找法

方法

定义

方法重载

递归(recursion)

JVM内存模型

方法内基本数据类型内存的变化

基本数据类型栈的内存变化

引用类型的堆栈内存的变化

方法调用方法时内存的变化

计算机存储单元

  1. 什么是字节（byte）：计算机最小的存储单元（如：水杯）---bit（位，比特位）

  2. 其他的存储单位：

    • 1B（字节）=8bit

    • 1KB=1024B

    • 1MB=1024KB

    • 1GB=1024MB

进制
  1. 十进制 10 12 15
  2. 二进制 10101000，00100010
  3. 需求：10转换成二进制
数据类型 基本数据类型

  1. byte -128——127

    //这里演示 byte demo
public class ByteDemo{
    public static void main(String []args){
        Byte b = 12;
        System.out.println(b);
    }
}

  2. short

    //这里演示 short demo
public class ShortDemo{
    public static void main(String []args){
        Short s = 12;
        System.out.println(s);
    }
}

  3.  其他基本数据类型

    public class Demo{
    public static void main(String []args){
        //整形
        short b = 12;
        System.out.println(b);
        //int
        //int的默认值是0
        int i = 10;
        System.out.println(i);
        //long
        long l = 10;
        System.out.pritln(l);
        //浮点型
        //double
        double d = 3.5D;
        System.out.pritln(d);
        //float
        float f = 3.6f;
        System.out.println(f);
        //char字符型
        char c = '男';
        System.out.println(c);
        //boolean
        boolean bo = true;
        Sysyem.out.println(bo);
    }
}
引用数据类型

String的简单使用：

public class StringDemo{
    public static void main(String []args){
        //String的基本使用
        String str = "学习使用String";
        System.out.println(str);
    }
}
强制类型转换 
float f1 = 3.7f;
int intTestF = (int)f1;
System.out.println(intTestF);
double d1 = 1.2;
int intTestD = (int)d1;
System.out.println(intTestD);
常量

定义：永远不会变的量 10，100，10.3，1000L，10.4F

final修饰的 
public class ConstantDemo{
    public static void main(String []args){
        //常量
        final int i = 10;
    }
}
变量

定义格式：

//数据类型  变量名  赋值符号  数值
    int      i      =         10;

代码演示：

public class VariableDemo{
    public static void main(String []args){
        double d = 3.5;
        d = 3.6;
        System.out.println(d);
        
        String str = "上云";
        str = "上云17";
        System.out.println(str);
        
        final int i = 10;
        i = 20;
        System.out.println(i);//如果给final修饰的变量赋值，就会报错
    }
}
运算符 算数运算符+，-，*，/，%，++，-- 
//演示 *** 作运算符
public class OperatorDemo{
    public static void main(String []args){
        //=,-,*,/,%,++,--
        int a = 10;
        int b = 20;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        a = 3;
        System.out.println(a % b);
        System.out.println("----------分割线 后置++-----------");
        //演示++，--
        int c = 5;
        c++;
        System.out.println(c);
        c--;
        System.out.println(c);
        System.out.println("----------分割线 前置++-----------");
        int d = 5;
        ++d;
        --d;
        System.out.println(d);
        System.out.println("-------------分割线 前置++与后置++----------");
        int f = 10;
        int e = 2;
        int g = ++e + f;
        System.out.println(g);
        System.out.println(e);
    }
}

注意：前置++和后置++的区别，前置++先+1后运算，后置++先运算后+1

关系运算符 
System.out.println(10 > 20);
System.out.println(10 >= 20);
System.out.println(10 < 20);
System.out.println(10 == 20);
System.out.println(10 != 20);
逻辑运算符& | ! ^ &&（短路与） ||（短路或） 
boolean b0 = true;
boolean b1 = false;
System.out.println(b0 & b1);//false
System.out.println(b0 | b1);//true
System.out.println(!b0);
System.out.println(b0 ^ b1);//true,两者不一样返回true
System.out.println(b0 && b1);//flase
System.out.println(b0 || b1);//true
三目运算符

boolean?值1:值2（前面为true取值1否则取值2）

int i3 = 10;
int i4 = 20;
int i5 = i3>i4?5:6;
System.out.println(i5);//6
赋值运算符 
public class OperatorDemo1{
    public static void main(Sting []args){
        int a = 10;
        int b = 20;
        System.out.println(b);
        a += a;
        System.out.println(a);
        int c = 20;
        System.out.println(c -= 30);
        //byte short
        byte by = 10;
        byte by1 = 20;
        //默认的整型是int
        byte by2 = (byte)(by + by1);
        System.out.println(by2);
        int d = 10;
        d += 20;//d = d +20
        System.out.println(d);
        //字符串的连接
        String str1 = "我爱学";
        String str2 = "Java";
        System.out.println(str1 + str2);
        char ch3 = 'c';
        System.out.println(ch3);
    }
}
条件与循环语句 选择结构if

  1. if

    //if的定义
if(boolean){
    ...语句
}

  2. if...else

    //if...else
if(boolean){
    ...语句1;
}else{
    ...语句2;
}

  3. if...else if...else

    if(boolean){
    ...语句1;
}else if(boolean){
    ...语句2;
}else{
    ...语句3；
}
switch 
//定义
switch(表达式){
    case 目标值:
        执行语句
        break;
    case 目标值:
        执行语句
        break;
    default:
        执行语句
}
while 
//定义
while(boolean){
    语句
}
do...while 
do{
    语句
}while(boolean);
//do...while语句至少执行一次
for循环 
for(表达式1;表达式2;表达式3){
    语句
}
//执行表达式1，执行表达式2并判断结果，true则执行语句，后执行表达式3
break和continue

作用：跳转语句

  1. break（直接结束循环）

  2. continue（停止本次循环，继续加一次循环）

嵌套循环

特点：最外层的循环执行一次，里面全部执行完，再去执行外层循环

//定义
for(表达式1;表达式2;表达式3){
    for(表达式1;表达式2;表达式3){
        语句
    }
}
数组 
//动态定义
数据类型[] 变量名 = new int[30];
//动态定义
数据类型[] 变量名 = new int[]{值1,值2};
数据类型[] 变量名 = {值1,值2};

注意：

  1. 数组长度：变量名.length

  2. 数组的下标是从0开始的

  3. 数组下标的最大值是长度减一

数组的遍历

  1. for循环遍历

    //变量名.fori
for(int i = 0;i < 变量名.length;i++){
    语句
}

  2. foreach遍历

    //变量名.iter
for(int i : 变量名){
    语句
}
数组的特点
  1. 数组元素的数据类型必须一致，char有ascii码表对应
  2. 数组元素连续，空间大小一致，呈现一种线性结构
  3. 数组的长度一旦固定就不可改变
  4. 数组不仅可以存储基本数据类型也可以存储引用数据类型
数组的优缺点 优点

  1. 根据索引去访问元素

  2. 能存储较多数据

  3. 根据索引遍历

缺点

  1. 根据内容去找索引很慢

  2. 数组的大小一旦确定就不能改变

  3. 数组只能存储一种数据类型

foreach的底层 
//自己写的
for (int age1 : ages) {
    System.out.println(age1);
}
//字节码饭编译
for(i1 = 0; i1 < ((object[])ages2).length; ++i1){
}
//底层还是使用for循环
检索速度快

  1. 内存地址是固定的且是线性结构

  2. 可快速根据索引值找到所对应的数值

数组拷贝及扩容

  1. 首先要有两个数组

  2. 需要知道从哪拷贝到哪，拷贝多长

    public class CopyDemo {
    public static void main(String[] args) {
        int[] ages = {15,17,20,13,12};
        int srcPos = 2;//从原数组开始拷贝的位置
        int index = 3;//拷贝的长度
        int[] newAges = new int[3];
        int destPos = 0;//新数组开始拷贝的位置
        for (int i = srcPos; i < srcPos+index; i++) {
            newAges[destPos++] = ages[i];
        }
        for (int newAge : newAges) {
            System.out.println(newAge);
        }
    }
}
数组工具类Arrays

常用方法：Arrays.toString();

public class ArrayPrintDemo {
    public static void main(String[] args) {
        int[] ages = {15,17,20,13,12};
        String ret = "[";
        for (int i = 0; i < ages.length; i++) {
            if(i==ages.length-1){
                ret = ret +ages[i]+"]";
            }else{
                ret = ret+ages[i]+",";
            }
        }
        System.out.println(ret);
    }
}
//结果：[15,17,20,13,12]
二维数组 
//定义：
int[][] arrays = new int[][]{{1,2,3},{2,3}};
int[][] arrsys = {{1,2,3},{2,3}};
int[][] arrays = new int[2][3];
//遍历二维数组依然是for循环，第一次村换拿到的是一维数组，再次循环得到二维数组每个具体的值
import java.util.Arrays;
public class TwoArrayDemo {
    public static void main(String[] args) {
        int[][] arrays = new int[][]{{1,2,3},{3,5}};
        for (int i = 0; i < arrays.length; i++) {//第一层循环拿到具体的一位数组元素
//            System.out.println(arrays[i]);
            String s = Arrays.toString(arrays[i]);
            System.out.println(s);
            for (int i1 = 0; i1 < arrays[i].length; i1++) {//第二层通过第一层数组循环取值
                System.out.println(arrays[i][i1]);
            }
        }
    }
}
//结果：
//[1, 2, 3]
//1
//2
//3
//[3, 5]
//3
//5
算法
  1. 数值交换 
    //例：a和b交换
int temp = a;
a = b;
b = temp;
  2. 冒泡排序 
    import java.util.Arrays;
public class BubbleSortDemo {
    public static void main(String[] args) {
        int[] newHeight = {3,9, 2, 6, 7, 4, 1};
        for (int i = 1; i <= newHeight.length - 1; i++) {
            for (int j = 1; j <= newHeight.length - i; j++) {
                if (newHeight[j - 1] > newHeight[j]) {
                    int temp = newHeight[j - 1];
                    newHeight[j - 1] = newHeight[j];
                    newHeight[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(newHeight));
    }
}
  3. 选择排序 
    import java.util.Arrays;
public class SelectionSortDemo {
    public static void main(String[] args) {
        int[] arrays = {9, 2, 6, 7, 4, 1};
        for (int i = 1; i < arrays.length; i++) {
            for (int j = i; j < arrays.length; j++) {
                if (arrays[i - 1] > arrays[j]) {
                    int temp = arrays[i - 1];
                    arrays[i - 1] = arrays[j];
                    arrays[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrays));
    }
}
  4. 二分查找法 
    /**
 * 二分查找法
 */
public class BinarySearchDemo {
    public static void main(String[] args) {
        //数组的值要从小到大排列
        int[] arrays = {1,2,4,6,7,9};
        int num = 1;
        int min = 0;
        int max = arrays.length-1;
        while(min<=max){
            int mid = (min+max)/2;
            int midValue = arrays[mid];
            //大于往左边找
            if(midValue>num){
                max =mid;
                //小于往右边找
            }else if(midValue
方法 定义 
修饰符 返回值类型 方法名称(形式参数){
    方法体
}
//方法形参的可变参数
public static int addSum(int ... arr){
    int sum = 0;
    for(int i : arr){
        sum += i;
    }
    return sum;
}
public static void main(String[] args){
    System.out.println(addSum(1,2,3,4,5,3,3,3,3,3));
}
方法重载

  1. 定义：在同一个类里面允许存在一个以上的同名方法，参数列表不同。

  2. 注意：

    • 必须在同一个类里面

    • 方法名必须相同

    • 形参列表不一样（参数类型，参数个数，参数顺序）

    • 和返回值类型无关

递归(recursion)

定义：方法自己调用自己

需求：使用递归计算5的阶乘

public class RecursionDemo{
    public static void main(String[] args){
        System.out.println(recursion(5));
    }
    //递归方法
    public static int recursion(int a){
        if(a == 1){
            return 1;
        }
        //自己调用自己
        return a * recursion(a - 1);
    }
}
JVM内存模型

  1. 程序计数器：当前线程执行的字节码的行的指示器

  2. 本地方法栈：虚拟机使用的native方法

  3. 虚拟机栈：创建栈帧，用于存储局部变量， *** 作数栈，动态连接，方法的返回地址

  4. 堆：所有线程所共享的一块内存区域（如数组，分配到堆内存，使用new关键字都会在堆内存里面开辟空间）

  5. 方法区（元空间）：线程所共享

    常量池（String str = "abc";）

  6. GC（垃圾回收器）：不定时将一些不使用的内存自动回收，不需要手动 *** 作

方法内基本数据类型内存的变化 基本数据类型栈的内存变化

  1. 先进后出的原则

  2. 不会改变彼此的数据（独立的，是一个指向）

  3. 存在栈里面的数据是可以共享的

引用类型的堆栈内存的变化

方法调用方法时内存的变化
  1. 需求：定义一个add计算器的方法，我们在主方法里面调用 
    public class StacksHeapDemo{
    public static void main(String[] args){
        int num1 = 10;
        int num2 = 20;
        int ret = add(num1 , num2);
        System.out.println(ret);
    }
    public static int add(int a, int b){
        return a + b;
    }
}

  2. 定义一个add方法，add传的是数组，要把数组里面的元素求和 
    public class StacksHeapsDemo{
    public static void main(String[] args){
        int[] ages = {1,3,5};
        int ret = add(ages);
        System.out.println(ret);
    }
    public static void add(int[] arr){
        int sum = 0;
        for(int i : arr){
            sum +=i;
        }
        return sum;
    }
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/799401.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-05-06
下一篇 2022-05-06

发表评论

登录后才能评论

评论列表（0条）

保存