首页 > 编程语言 >javase

javase

时间：2022-11-01 13:55:25浏览次数：36  
标签：int System 数组 println javase public out

1.HelloWord

1.新建一个java项目

  • 文件后缀名为.java
  • Hello.java
  • 注意点系统可能没有显示后缀名，需要手动打开

2.编写代码

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello,World!");
    }
}
//Hello World!

4.编译javac.java文件，会生成一个class文件

5.运行class文件，java.class文件

注意：

  1. 单词的大小写要注意：java的语法规则，对大小写敏感
  2. 尽量使用英文命名
  3. 文件名和类名必须保持一致，首字母大写
  4. 符号不能使用中文符号

2.注释、标识符、关键字

2.1注释(注释不会被执行)

在代码量、项目结构复杂时，需要用到注释

注释是给写代码的人看的

单行注释

//Hello World
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello,World!");
    }
}

快捷键：CTRL+/

多行注释

注释一段文字

/*
hhhh
hhhh
hhhhh
 */
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello,World!");
    }
}

文档注释

javaDoc指令

/**
     *
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception {
        return name;
    }

参数信息

@author作者名

@version版本号

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

@param参数名

@return返回值情况

@throws异常抛出情况

2.2标识符

java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符

标识符注意点

  • 所有的标识符都以字母(A-Z/a-z)、美元符$、下划线_开始
  • 首字母可以是字母(A-Z/a-z)、美元符$、下划线_或数字的任何字符组合
  • 不能使用关键字作为变量名或方法名
  • 标识符是大小写敏感的
  • 合法标识符举例：age、$salary、_value
  • 非法标识符：123abc
  • 可以使用中文拼音命名，但是不推荐，很low

3.数据类型

强类型语言：

要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。

弱类型语言：

3.1基本类型

字节：

位(bit)：计算机内部储存的最小单位，11001100是八位二进制数

字节(byte)：是计算机中数据处理的基本单位，可以用B表示

1B(byte)=8bit(位)

1024B=1KB

1024KB=1MB

1024MB=1GB

字符：指计算机中使用的字母、数字、字和符号

转义字符（\t \n）空格 换行

数据类型：

整数类型：

byte

short

int

long

浮点类型：

float

特点：有限 离散 舍入误差 大约 接近但不等于

 float f = 0.1f;     //0.1
        double d = 1.0/10;    //0.1
        System.out.println(f==d);   //false
        System.out.println(f);  //0.1
        System.out.println(d);  //0.1

        float d1 = 23232322222223222f;
        float d2 = d1 + 1;
        System.out.println(d1==d2); //true

double

字符类型：

char

boolean类型

默认值为false

true

false

3.2引用类型

类

接口

数组

4.类型转换

java是强类型语言，有些运算需要用到类型转换

(byte、short、char、int、long、float、double)

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

public class demo03 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i;  //byte最大值为127,导致内存溢出
        //强制转换  （类型）变量名     高-->低
        //自动转换  低-->高

        System.out.println(i);	//128
        System.out.println(b);	//-128

5.变量、常量、作用域

5.1变量：可以变化的量

java是一种强类型语言、每个变量都必须声明其类型

java变量是程序中最基本的存储单元，包括(变量名、变量类型和作用域)

变量的命名规范：

  • 所有变量、方法、类名：见名知意
  • 类成员变量：首字母小写驼峰原则
  • 局部变量：首字母小写驼峰原则
  • 常量：大写字母和下划线
  • 类名：首字母大写驼峰原则
  • 方法名：首字母小写驼峰原则

注意：

  • 每个变量都有类型，类型可以是基本类型或引用类型
  • 变量名必须是合法的标识符
  • 变量声明是一条完整的语句，每个声明都必须以分号结束。

5.2变量作用域

类变量 static

实例变量：从属于对象,若不自行初始化，这个类型默认值;除了基本类型其余的默认值为null

局部变量：必须声明和初始化值

​

public class demo04 {
	static int allClicks = 0;       //类变量
    String str = "helloworld";      //实例变量
    public void method(){
        int i = 0;                  //局部变量
    }

5.3常量（关键字final）

常量：初始化后不能再改变值，不会变动的值。

常量可以理解成一种特殊的变量，值被设定后，在程序运行中不允许被改变

常量名一般用大写字符

//final 变量名=值;
        final double PI = 3.14;

final修饰符不存在先后顺序

6.运算符

  • 算术运算符：+、-、*、/、%、++、--
  • 赋值运算符：=
  • 关系运算符：> 、<、>=、<=、==、!=
  • 逻辑运算符：&&、||、!
public class demo04 {
    public static void main(String[] args) {
        //与(and)    或(or)   非(取反)
        boolean a = true;
        boolean b = false;
        System.out.println("a && b:"+(a&&b));       //逻辑与运算：两个变量都为真，结果才返回为true
        System.out.println("a || b:"+(a||b));       //逻辑或运算：其中一个变量为真，结果返回为true
        System.out.println("!(a && b)"+!(a&&b));     //逻辑非运算：如果是真，则变为假；如果是加变为真
    }

与(and) 或(or) 非(取反)

结论：

逻辑与运算：两个变量都为真，结果才返回为true

逻辑或运算：其中一个变量为真，结果返回为true

逻辑非运算：如果是真，则变为假；如果是加变为真

  • 位运算符：&、|、^、~、>>、<<、>>>(了解即可)

(>>) *2

(<<) /2

底层代码，效率很高
二进制（逢二进一）
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16

  • 条件运算符：?、:(了解即可)
  • 拓展赋值运算符：+=、-=、*=、/=(了解即可)
  • 三元运算符

x ? y : z
//如果x为true,则结果为y,否则结果为z

7.包机制

com.xx

阿里巴巴基础手册

8.流程控制

8.1Scanner对象

java.util.Scanner是java5的新特征,实现程序和人的交互

基本语法：Scanner s = new Scanner(System.in);

通过Scanner类的next()与nextLine()方法获取输入的字符串，读取前一般要使用hasNext()与hasNextLine()判断是否还有输入的数据

next():

  1. 一定要读取到有效字符后才可以结束输入
  2. 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
  3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
  4. next()不能得到带有空格的字符串

nextLine():

  1. 以enter为结束符，nextLine()方法返回的是输入回车之前的所有字符
  2. 可以获得空白

8.2顺序结构

java的基本结构是顺序结构，一般按顺序一句一句执行

顺序结构是最简单的算法结构

顺序结构是任何一个算法都离不开的一种基本算法结构

8.3选择结构

if单选择结构

public class IfDemo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容");
        String s = scanner.nextLine();

        if (s.equals("Hello")){
            System.out.println(s);
        }

        System.out.println("End");
        scanner.close();
    }
}

if-else双选择结构

public static void main(String[] args) {
        //考试分数大于60分为及格否则不及格
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入考试分数");
        int score = scanner.nextInt();
        if (score >= 60){
            System.out.println("及格");
        }else {
            System.out.println("不及格");
        }

        scanner.close();
    }

if多选择结构

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的考试分数");

        int score = scanner.nextInt();
        if (score <= 100 && score >=90){
            System.out.println("成绩优秀");
        }else if (score <90 && score >= 70){
            System.out.println("成绩良好");
        }else  if (score < 70 && score >= 60){
            System.out.println("成绩及格");
        }else if (score < 60 && score >= 0){
            System.out.println("成绩不及格");
        }else {
            System.out.println("输入的数字有误");
        }
        scanner.close();
    }
switch多选择结构

判断一个变量与一系列值中某个值是否相等。每个值称为一个分支

8.4循环结构

while结构

最基本循环 while(布尔表达式){ //循环内容 }

只要布尔表达式为true，循环就会一直执行下去

大多数情况会让循环停止下来，需要一个让表达式来结束循环

public static void main(String[] args) {
        int num = 0;
        int sum = 0;
        while (num <= 100){
            sum = sum + num;
            num++;
        }
        System.out.println(sum);
    }

do……while结构

public static void main(String[] args) {
        int num = 0;
        int sum = 0;
        do {
            sum = sum +num;
            num++;
        }while (num <= 100);
        System.out.println(sum);
    }

do……while至少会执行一次

do{ //代码语句 }while(布尔表达式);

While和do……While区别

  • while先判断后执行，dowhile先执行后判断
  • do……while至少执行一次

for循环

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

语法格式：for(初始化;布尔表达式;更新){ //代码语句 }

九九乘法表

public static void main(String[] args) {

        for (int y = 1; y < 10; y++) {
            for (int x = 1;x <= y; x++){
                System.out.print(x+"*"+y+"="+(x*y)+"\t");
            }
            System.out.println();
        }
    }

增强for循环

使用重点在数组

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

声明语句：

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

表达式：

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

8.5break continue goto

break

break在任何循环语句的主体部分，均可以break控制循环的流程，break用于强行退出循环，不执行循环剩余的语句

continue

continue语句用在循环体语句中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判断。

关于goto关键字

goto关键字很早就出现在程序设计语言中，尽管goto仍是java的一个保留字，但并未在语言中正式使用；break和continue有goto的影子

9.方法

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

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

方法包含于类或对象中

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

设计方法的原则：

方法本意是功能块，就是实现某一个功能的语句块的集合。

设计方法时，最好保持方法的原子性(一个方法只完成一个功能，利于后期的拓展)

8.1.定义：

用来完成特定功能的代码片段

语法结构：修饰符 返回值类型 方法名（参数类型 参数名）

​ {方法体 return 返回值;}

方法包含一个方法头和一个方法体

修饰符：可选的，告诉编译器如何调用该方法，定义该方法的访问类型

返回值类型：方法可能会返回值。returnValueType时方法返回值的数据类型。有些方法没看有返回值，使用关键字void

方法名：方法名和参数表共同构成方法签名

参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。值被称为实参或变量。参数列表指方法的参数类型、顺序和参数的个数。参数是可选的

  • 形式参数：在方法被调用时用于接受外界输入的数据
  • 实参：调用方法时实际传给方法的数据

方法体：包含具体的语句、定义该方法的功能

方法调用：对象名.方法名(实参列表)

当方法返回一个值时，方法调用通常被当作一个值

public static void main(String[] args) {
        int max = max(4, 3);
        System.out.println(max);
    }
    public static int max(int a,int b){
        int result = 0;
        if (a == b){
            System.out.println(result);
        }
        if (a > b){
            result = a;
        }else {
            result = b;
        }
     return result;
    }

方法的返回值是void，方法调用一定是一条语句

8.2.方法的重载

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

规则：

方法名称必须相同

参数列表必须不同

方法的返回类型可以相同也可以不相同

8.3可变参数

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

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

8.4递归

递归就是：A方法调用A方法，就是自己调用自己

结构部分：

递归头：什么时候不调用自身方法（没有头进入死循环）

递归体：什么时候需要调用自身方法

小计算可以使用

9.数组

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

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

每一个数据称作数组元素，每个数组元素通过一个下标来访问

9.1数组声明创建

先声明数组变量，才能在程序中使用数组

int[] num;  //定义    首选此方法

java语言使用new操作符来创建数组

num = new int[10];     //创建一个数组，存放10个int类型的数字

数组的元素是通过索引访问，数组索引从0开始

获取数组长度

array.length()

9.2内存分析

堆：存放new的对象和数组 可以被所有的线程共享，不会存放别的对象引用

栈：存放基本变量类型（包含这个基本类型的具体数据） 引用对象的变量（会存放这个引用在堆里面的具体地址）

方法区：可以被所有的线程共享 包含所有的class和static变量

9.3三种初始化

静态初始化

//静态初始化
int[] a = {1,2,3,4,5};
System.out.println(a[0]);
//输出1

动态初始化

//动态初始化
        int[] ints = new int[10];
        ints[0] = 8;
        System.out.println(ints[0]);

数组的默认初始化

9.4数组的基本特点

  1. 数组的长度是确定的。数组一旦被创建，数组的大小不可以改变
  2. 数组的元素必须是相同类型，不允许出现混合类型
  3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型
  4. 数组变量属于引用类型，数组可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

9.5数组边界

下标的合法区间：[0,length-1],越界就会报错

public static void main(String[] args){
    int[] a = new int[2];
    System.out.println(a[2]);
}

ArrayIndexOutOfBoundsException：数组下标越界异常

小结：

  • 数组是相同数据类型（数据类型可以为任意类型）的有序集合
  • 数组也是对象。数组元素相当于对象的成员变量
  • 数组长度的确定是不可变的，不能越界

9.6多维数组

多维数组可以看成是数组的数组

二维数组就是一个特殊的一维数组

int a[][] = new int[2][5];

9.7Arrays类

数组的工具类java.utli.Arrays

由于数组对象本身没有什么方法可以调用，API中提供了一个工具类Arrays使用，可对数据对象进行一些基本操作

查看JDK帮助文档

Arrays类中的方法都是static修饰的静态方法，使用的时候可以直接使用类名调用

常用功能：

  • 给数组赋值：fill方法
public static void main(String[] args) {
    int[] a = {1,2,3,4,90,909,21,23};
    Arrays.fill(a,0);   //给数组数值进行填充
        System.out.println("调用java的Arrays工具类，fill填充输出数组"+Arrays.toString(a));
    }
//输出的结果：[0, 0, 0, 0, 0, 0, 0, 0]
  • 对数组排序：sort方法，升序
public static void main(String[] args) {
    int[] a = {1,2,3,4,90,909,21,23};
    Arrays.sort(a); //数组进行排序，升序
        System.out.println("调用java的Arrays工具类，sort有序输出数组"+Arrays.toString(a));
    }
//输出的结果：[1, 2, 3, 4, 21, 23, 90, 909]
  • 比较数组：通过equals方法比较数组中元素值是否相等
  • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

9.8冒泡排序

两层循环，外层冒泡轮数，里层依次比较

//冒泡排序（经典中的经典）
public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {1,4,2,7,3};
        int[] sort = sorts(a);
        System.out.println(Arrays.toString(sort));
    }
    //1.比较数组中，两个相邻的元素，若第一个数比第二个数大，交换他们位置
    //2.每一次比较，会产生一个最大的或最小的数字
    //3.下一轮会减少一次排序
    //4.依次循环
    public static int[] sorts(int[] arrays){
        //临时变量
        int temp = 0;


        //外层循环，判断要走多少次
        for (int i = 0; i < arrays.length-1; i++) {
            boolean flag = false;   //通过flag标识符减少没有意义的比较

            //内层循环，如果第一个数比第二个数大，交换位置
            for (int j = 0; j < arrays.length-1-i; j++) {
                if (arrays[j+1]<arrays[j]){
                    temp = arrays[j];
                    arrays[j] = arrays[j+1];
                    arrays[j+1] = temp;
                    flag = true;
                }
            }
            if (flag == false){
                break;
            }

        }
        return arrays;
    }
}

9.9稀疏数组

编写五子棋游戏，有存盘退出和续上盘的功能

介绍：

当一个数组中大部分元素为0，或为同一值的数组时，可以使用稀疏数组来保存该数组

处理方法：

  • 记录数组共有几行几列，有多少个不同值
  • 把具有不同值的元素和行列及值记录在一个小规模的数组中，缩小程序的规模（压缩）

运行

  1. 创建原始数组，把最初的数组输出
  2. 程序运行之后有两个有效值，定义array1二维数组为11行11列，第一个有效值在第二行第三列值为1，第二个有效值在第三行第四列值为2
  3. 转换为稀疏数组，定义循环得到array1数组的有效值并判断数组值之间相乘为不为0（数组的默认值为0），获取有效值的个数
  4. 创建稀疏数组，将array1非0的值保存到稀疏数组中
  5. 输出稀疏数组的值
//稀疏数组
public class ArrayDemo07 {
    public static void main(String[] args) {
        //1.创建一个二维数组11*11   0：没有棋子  1：黑棋    2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
//        转换为稀疏数组
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);

        //创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零的值，存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        System.out.println("稀疏数组");
        System.out.println("行"+"\t"+"列"+"\t"+"有效值");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]);
        }
    }
}

文章内容来源：

这是我在b站看狂神说java基础做的笔记。

标签：int,System,数组,println,javase,public,out
From： https://www.cnblogs.com/hqLGX/p/16847420.html

相关文章

  • 【❤️Java入门超简单❤️】JavaSE初级教程整合篇，全部手敲，每一节代码都验证可行（建议新人收
    大家好，我是spring小杨，是一位java司机，喜欢撸代码，可技术交流！我对自己编写的Java初级教程做了一个整理，每一节都是我用心编写而成。该教程和我的学习网站：java18.cn是同步的。终......
  • javaSE day02
    字面量888888  80 说明一下首先“id”不足8个字符，所以要加”\t“补全，但是”20204206“满足八个字符，添加就会加8个空格，不添加就会造成与后文相连，所以上......
  • 【JavaSE】Java常用类
    1.String的特性代表字符串，java中所有字符串字面值都作为此类的实现例实现。String是一个final类，不能被继承。String实现了Serialiable，表示字符串支持序列化，实现了Comarabl......
  • javaSE02基础语法
    java基础语法IDE的使用IDE(IntegratedDevelopmentEnvironment)集成开发环境包含编辑器,编译器,调试图形界面IntelliJIDEA捷克的一家公司收费的EclipseIBM公司开发的......
  • javaSE01概述与第一个程序
    java概述与第一个程序为什么是java市场需求高java语言用途广:服务器程序,Android应用,软件工具,嵌入式领域,大数据技术Java语言发展史1991年SUN公司詹姆斯•高斯林提出要求:......
  • javaSE06基础-对象与引用-基本类型和引用类型的区别
    面向对象2对象与引用引用对象:Java语言中除基本数据类型之外的变量类型都称为引用类型.java中的对象是通过引用对其操作的例如:我们有一个自定义类为Car（汽车类）classCar{S......
  • javaSE10--final关键字-抽象类-接口-抽象类接口区别
    final关键字final用于声明属性,方法和类,可以修饰类,修饰字段,修饰方法,修饰局部变量,修饰形参属性:定义就必须直接赋值或者在构造方法中进行赋值,并且后期不能修改,修饰修......
  • javaSE09基础-面向对象三大特征
    面向对象特征封装封装概念:封装,将类的某些信息隐藏在类内部,不允许外部访问,而且时通过该类提供的方法来实现对隐藏信息的操作和访问优点:隐藏类的实现细节类内部的结构可......
  • javaSE13-- API_常用类--默认继承Object--toString()--==与equals()[详解]
    API_常用类API应用程序编程接口API文档是对Java预定定义的类或接口功能和方法功能的说明文档,目的是提供给开发人员进行使用帮助说明默认继承Object,Java中所有类没有显示的......
  • javaSE基础-比较器
    Java比较器1、java对象正常情况下只能进行==或!=，不能进行比较大小。若需要比较对象的大小，需要实现两个接口中的任何一个：Comparable或Comparator2、Comparable接口......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99