华清远见重庆中心—Java基础阶段技术总结

最新推荐文章于 2024-05-24 02:08:26 发布

m0_68481241

最新推荐文章于 2024-05-24 02:08:26 发布

阅读量193

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/m0_68481241/article/details/127858249

版权

华清远见重庆中心—Java基础阶段技术总结

Java概述

Java能做什么

java的分类

JavaME
JavaSE
JavaEE

JavaME称为Java微型版，用于开发移动应用，早起塞班系统中会使用，如今已经被淘汰

JavaSE称为Java标准版，是Java的核心和基础，也是JavaME和JavaEE的核心，可以用于开发桌面端成都。如IDEA就是用java开发

JavaEE称为Java企业版，用于开发WEB应用。Java的流行全靠JavaEE。WEB应用如门户网站、电子商务、电子政务等服务器都是JavaEE实现。

现阶段，我们主要学习JavaSE

Java为什么流行

Java是一门跨平台“半解释半编译”的“面向对象”语言。

Java有很多优点，尤其是这几点

简单
安全
开源
多线程
半解释半编译
面向对象

Java能够跨平台运行原理

Java有一个最大的特点就是跨平台:“一处编译，处处运行”。

Java有一个核心：JVM称为Java虚拟机。它用于Java字节码文件。

在不同的平台上，安装JVM后，就能解释当时编译的字节码文件。

开发人员在编辑完Java代码后，会保存为.Java的源文件，

将源文件经过编译后，会生成.class的字节码文件，

由JVM解释字节码文件。

安装Java后，会安装JVM以及JDK和JRE

Java程序的运行流程

编辑,java源文件—>javac命令编译—>生成class字节码文件—>java命令由jvm解释运行

Java代码中的注意事项

符号

java中的符号必须全部是英文状态下的符号

"{}"必须成对出现,用于定义类定义方法和定义代码块

"[]"必须成对出现,用于定义数组,使用数组

"()"必须成对出现,用于表示方法的参数

"空格"用于

编程语言的命名规则

驼峰命名法

如果使用多个单词描述一个内容，除首字母玩，其他单词的首字母大写

如：studentName、studentClass等

帕斯卡命名法

所有的单词首字母全部大写

如：StudentName 、StudentClass等

Java中的标识符

Java中的类名、方法名、变量名统称为标识符。

Java中，类名使用帕斯卡命名法
方法名和变量名使用驼峰命名法
命名时最好做到"见名知意"

这些要求并不是强制性的，如果你不想这么命名程序也不会报错，只是开发人员共同约定的内容

Java中标识符的命名规则

标识符只能使用数字、字母、下划线和美元符号$组成
其中，数字不能作为标识符的开头
不能使用Java的关键字(保留字)

见下图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N48uwUPs-1668442074718)(C:\Users\ushop\AppData\Roaming\marktext\images\2022-11-14-22-58-47-image.png)]

这些要求是必须执行的，强制的，如果不照做，那么无法通过编译

命名举列：

类名(遵循帕斯卡命名法)：

Test Animal Cat Dog StudentClass

变量名(遵循驼峰命名法)：

age lastName firstName

方法名(遵循驼峰命名法)：

常量(全大写):

COUNTRY_NAME

Java中的数据类型

Java中分为两大数据类型：原始(基本)数据类型和引用类型

原始(基本)类型

整型

byte 字节

short 短整型

int 整型

long 长整型

浮点型

float 单精度浮点型，赋值时，在数字后加上f或者F

double 双精度浮点型

字符型

char 赋值时可以是单引号引起来的一个字符或者是一个数字，这个数字是ascll表中的数字或者是一个转义字符

ascll码表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8YrPctfP-1668442074719)(C:\Users\ushop\AppData\Roaming\marktext\images\2022-11-14-23-11-56-image.png)]

布尔型

boolen

类型名	所占字节大小	范围
byte	1字节	-128~127
short	2字节	-32768~32767
int	4字节	-2^63~263-1
long	8字节	-2^64“ ~”2^64 -1
float	4字节	3.4 10^-38 ~3.4 10^38
double	8字节	-2^1024 ~ +2^1024
char	2字节	用单引号引起来的一个字符在java中，不管是数字还是英文还是憨子，char都占用2个字节
boolean	—	true/flase

在一个程序中，默认写出的整数是int类型，小数是double类型

原始类型之间的数据类型转换

隐式类型转换(自动类型转换)

占用字节小的数据类型的变量，可以保存在占用字节大的数据类型变量中

如：

short s=123;
int i=s;
//short占用2个字节，int占用4个字节，所以s能存到i中

显示类型转换(强制类型转换)

占用字节大的数据类型的变量，默认无法保存到占用字节小的数据类型的变量中，

如果要强制保存，需要经过类型转换。

语法：(目标类型)待转化的变量

int num=123;
//byte b=num;//直接无法复制
byte b=(byte)num;//强制转换为byte类型
//如果带转换的变量中

引用类型

类
数组
接口

变量

在内存中的一块区域。由于这块去榆中的数据可以发生变化，所以称为变量

内存中的变量，相当于酒店中的房间。房间的类型就是变量的类型，房间的房号就是变量的名称，房间中的人就是变量的值

定义变量，就是在内存中申请一块相应数据类型的空间，并对其命名的过程

定义变量

语法：数据类型变量名;

如果要同时定义多个相同类型的变量,可以写作:数据类型变量名1,变量名2…

如

 //    定义年龄
        int age;
        //定义年月日
        int year;
        int month;
        int day;
        //定义中奖概率
        double p;
        //定义性别,用m表示男,w表示女
        char sex;
        //定义婚姻状态
        boolean married;

给变量赋值

语法:变量名=值;

 //    定义年龄
 int age;
 age = 20;

变量初始化

语法:数据类型变量名=值;

如果在定义变量的时候能确定其中保存的数据,可以直接在定义变量的时候赋值,并将定义变量和给变量赋值的过程合二为一

//定义年月日 
 int year=2022;
 int month=11;
 int day=8;

注意事项

在一对大括号(一个作用域)中,一个变量名只能被定义一次,变量名不能重复

public static void main(String[] args){
    int a=123;
    int a=123;//不可以
    double a=123;
    double A=123;/可以
}

变量赋值时,赋值符号"="左边可以是一个具体值,也可以是一个已赋值变量,或者是一个表达式。保证等号右边数据类型能被等号左边接纳（可以小赋值大）

int age=20;
int num=age;
boolean flag=2>1;//结果为true

如果同时定义多个类型相同的变量，可以只写一个数据

int year=2022,month=11,day=8

运算符

算术运算符

需要两个操作数

符号	作用
+	加
-	减
*	乘
/	除
%	取余数

关系运算符

需要两个操作数参与，计算结果为布尔型 boolean

符号	作用
>	大于
<	小于
>=	大于等于
<=	小于等于
!=	不等于
==	等于

逻辑运算符

符号	作用	说明
&&	and与	符号两端需要两个表达式，判断结果如果都为true，整体结果都为true，如果有一端结果为false，整体结果为false。
	\|	or或
！	not非	是一个单目运算符，只有一个表达式参与运算，"!原结果"对原表达式结果取反

补充：位运算符

符号	作用
&	按位与，计算的结果与&&相同，但过程不同，符号两端的表示都是执行完成

^	按位异或。2^3
>>	按位右移。将第一个操作数转换为二进制后，向后移动第二个操作数对应的位数，再将结果转换为10进制
<<	按位左移。将第一个操作数转换为二进制后，在后面补充第二个擦偶总数对应数量的0，再将结果转换为十进制

System.out.println(2^4);
        //2 二进制010 3 二进制011 4 100
        //6 110 

        //6 110 //011--3
        System.out.println(6>>1);
        //5 101 //1010
        System.out.println(5<<1);


        //1000  //0100
        System.out.println(8>>1);

        //1001 //10010
        System.out.println(9<<1);

注意

&&和||也称为短路运算，如果能通过第一个表达式决定最终的结果，则不用判断第二个表达式
通常情况下，使用&&和||提高代码执行效率

赋值和复合赋值运算符

符号	作用
=	赋值运算符，将符号右侧的内容赋值给符号左边的变量
+=	复合赋值运算符。a+=3相当于a=a+3
-=	复合赋值运算符
*=	复合赋值运算符a=b+c相当于a=a(b+c)
/=	复合赋值运算符
%=	复合赋值运算符

复合赋值运算的流程是：

将符号两端的整体进行相应的算术运算后，将结果赋值给符号左边的变量中

int a=3;
a*=a+2; //相当于a=a*(a

自增自减运算符

只有一个操作数参与运算，称为单目运算符

符号	作用
++	将结果+1
–	将结果-1

a++或++a相当与a+=1或者锕+1，–同理
如果++或者–独立成行使用，无论符号在前灾后，都将结果+1或者-1

int num=10;
        num--;
        System.out.println(num);

如果++或者–不是单独成行

符号在前，先+1或-1计算后再使用值

符号在后，先使用值后再计算+1或者-1

int a=3;
if(a++>3){
    //符号在后，先使用值。则3>3不成立
}
System.out.println(a);//a最终会+1，a为4


int b=4;
if(--b==3){
    //符号在前，先计算，则3==3成立
}
System.out.println(b);//b的结果为3


 int num=10;
        //num--;
        // System.out.println(num++);
        // System.out.println(num);
        System.out.println(num++ + ++num);//10+12

条件运算符

三目运算符，有三个操作数参与，是一个简化版的双分支条件语句

表达式1?表达式2:表达式3

首先运算表达式1，如果结果为true，执行问号后的表达式2；

如果结果为false，执行冒号后的表达式3

整个表达式最终结果为表达式2或者表达式3

运算符的优先级

小括号>>单目运算符(!、++、–)>>算术运算符>>关系运算符>>逻辑运算符>>条件运算符>>赋值/复合赋值运算符

条件语句

if语句

单分支if语句

如果代码满足则执行，不满足则不执行

if（判断条件）{
 //满足条件执行的代码   
}

如果一件事情满足则执行，不满足什么都执行

if(判断条件){//判断条件的结果为布尔型
    条件满足时执行代码;
}

双分支if语句

如果一个

if(判断条件){//判断条件的结果为布尔型
    条件满足时执行代码;
}else{
    条件不满足时候执行代码
}

多分支if语句

if(判断条件1){
    如果满足条件1执行
}else if(判断条件2){
    如果满足条件2执行
}else if(判断条件3){
    如果满足条件3执行
}else{
    如果所有条件都不满足执行
}

依次判断条件是否成立，如果有一个条件成立，执行后续的执行代码后，结束整个判断。后面的条件都不会执行

注意

范围小的条件写在前面

if嵌套

if(){
   if(){

} 
}else {
    if(){

}
}

if嵌套不要嵌套太多层，会导致代码可读性变低

switch语句

开关语句

如果一个变量的值能够全部举出时，使用switch语句

```java
switch(变量){//要判断的变量，只能是非long的整型、char、String
//变量的数据类型要与case后的数据类型相匹配
//不能出现重复的case
//break可以省略，如果不写break，在某个case匹配时，执行后续case后的代码，直到没有代码或者遇到break为止

    case 1:
        break;
    case 2:
        break;
    case 3:
        break;
    default:
        break;
}

if语句与switch语句的选择

如果条件能够一一列举出来，使用switch语句更加简洁
如果条件是一个范围时，只能使用if语句，如大于100
switch语句可以改写为if语句，if语句不一定能改为switch语句

循环语句

如果要重复执行某些代码时，使用循环语句

while

while(循环条件){//小括号里的条件，结果为boolean值
    满足循环条件时重复执行的代码
}

执行流程‘

先执行小括号中的内容，如果结果为true，执行大括号中的内容，再执行小括号中的内容，如果结果为false，则停止循环

while循环有可能一次都不执行

do-while

do{
   循环条件时重复的代码 
}while();

执行流程

先执行一次do后面大括号的内容，如果成立，在判断while小括号中的内容，如果不成立，停止循环

do-while循环至少执行一次

while和do-while的区别

while循环可能一次都不执行，do-while循环至少执行一次

for

for(表达式1;表达式2;表达式3){//表达式1为定义循环变量 表达式2为判断循环条件，表达式3为更新循环变量

}

执行流程

首先执行表达式1，再执行表达式2，如果表达式2的结果为true，执行循环体，再执行表达式3，再执行表达式2判断，如果表达式2结果为false，结束循环

循环作业代码

public class HomeWork {
    public static void main(String[] args) {
       /* int sum = 0, a = 1;
        for (int i = 1; i <= 10; i++) {
            a *= i;
            sum += a;

        }
        System.out.println(sum);*/


/*int tao=1,s=0;
        for(int i=9;i>0;i--){
            tao=(tao+1)*2;
            s+=tao;
            System.out.println(i+"天"+tao);

        }
        System.out.println(tao);*/


     /*   for(int i=1;i<10000;i++){
            int r=0;
            for(int j=1;j<i;j++){
                if (i%j==0){
                    r=r+j;
                }
            }
            if(r==i){
                System.out.println(i);
            }
        }*/
        for (int i = 1; i <= 5; i++) {
            for (int j = 1; j <= 5-i; j++) {
                System.out.print(" ");
            }
            for (int a = 1; a <= 2*i-1; a++) {
                System.out.print("*");
            }
            System.out.println();
        }

        for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <=i; j++) {
                System.out.print(" ");
            }
            for (int a=1;a<=9-2*i;a++) {
                System.out.print("*");
            }
            System.out.println();
        }

    }
}

数组（一维数组）

概念

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

关于数组

实际在内存中是一块连续的空间，是保存数据的区域

数组定义时需要确定大小和数据的类型，不可改变

定义数组时的变量

数据保存的数据称为元素，每个元素有一个唯一的位置，称为索引（下标），这个索引从0计数，可以通过数组的索引给数组赋值或者读取数组中某个索引上的值。

定义数组

语法：

数据类型[] 数组名或者数据类型数组名，建议使用前者

定义数组后，如果不初始化数组，数组无法使用

//定义数组。如果数组未初始化，不能使用
int[] score;
//可以这样写，但是不建议这样写
int score[];

数组初始化

语法：数组名=new 数据类型[数组大小];

score =new int[30];
//定义一个保存数组的变量
String[] nameList;
//在内存中申请一块连续空间，将这个空间的地址保存到变量nameList中
nameList=new String[10];

定义数组的同时初始化

语法：数据类型[] 数组名=new 数据类型[数组大小]；

double[] d=new double[30];

注意

数组一旦初始化后，数组大小不能改变，其中的元素类型要统一
数组的索引范围是[0,数组大小-1]，使用不能超出范围，在编译是无法识别是否超出数组索引，但是运行时会抛出"数组索引溢出"异常
数组一旦初始化后。如果没有赋值，默认有初始值

数组数据类型	默认值
整型	0
浮点型	0.0
引用类型	null
布尔型	false
字符型	空白字符

读取数据中的元素

通过 “数组名[索引]” 读取某个索引对应的元素

 int[] score=new int[]{1,2,3,7};//此时数组大小为4
        System.out.println(score[1]);

可以通过循环给数组赋值和读取元素

Scanner scanner = new Scanner(System.in);
        String[] stuName=new String[3];
        //循环赋值
        for (int i=0;i<stuName.length;i++){//通过数组名.length获得数组的长度
            System.out.println("请输入第"+(i+1)+"位同学名字");
            stuName[i]=scanner.next();

        }
        System.out.println("当前学生列表");
        //循环读取
        for (int i = 0; i < stuName.length; i++) {
            System.out.println(stuName[i]);
        }

增强for循环

专门用来遍历数组或者集合元素的一种循环

语法：for(数据类型变量名:数组名){}

String[] list={"a","b","c"}
for(String name : list){
    System.out.println(name);
}

给数组赋值

动态赋值

通过数组名[索引] 给数组中的某个位置赋值

int[] List=new int[10];
List[0]=123;//索引从0开始
List[9]=11;//最大索引为数组大小-1
List[22]=11;//能通过编译，但是运行时会出现数组越界异常

静态赋值

在定义数组的同时赋值

数据类型[] 数组名=new 数据类型[]{元素1,元素2,…};

int[] score=new int[]{1,2,3,7};

数据类型[] 数组名={元素1,元素,…}

int[] score={1,2,3,7};

数组作业

模拟双色球开奖


import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

/*
* 模拟双色球彩票开奖和购买记录
* 规则
* 红色球[1-33]选择6个不重复
* 蓝色球[1-16]之间选择一个
*
* */
public class SSQTest {
    public static void main(String[] args) throws InterruptedException {
        //模拟开奖
        //生成一个随机数方法
        //创建一个Random的对象
        Random rd=new Random();
        Scanner sc=new Scanner(System.in);
        //调用nextInt(值)方法，生成[0,值)区间的随机数

        //[0,32]+1=[1,33]
        //定义一个大小为6的数组保存红色球数字
        int[] red=new int[6];
        //定义一个购买的红色球数组
        int[] buyred=new int[6];
        for (int i = 0; i < red.length; i++) {
            red[i]=rd.nextInt(33)+1;
            for (int j=0;j<i;j++){
                if(red[i]==red[j]){
                    i--;
                }
            }
        }
        Arrays.sort(red);

        //购买的红色球数组用键盘键入
        System.out.println("请输入你要购买的6位红球号码：");
        for (int n=0;n<buyred.length;n++){
            System.out.println("第"+(n+1)+"个号码");
            buyred[n]=sc.nextInt();
            for (int m=0;m<n;m++){
                if (buyred[n]==buyred[m]){
                    System.out.println("不能购买两个相同的号码，请重新输入");
                    n--;
                }
            }
        }
        Arrays.sort(buyred);//把购买的红色球数组排序
        System.out.println("请购买一个篮球号码");
        //定义购买的蓝色球号码为键盘键入
        int buyblue=sc.nextInt();

        //蓝色球只有16，如果大于16，则需要重新输入一个数字
        if(buyblue>16){
            System.out.println("篮球只有1-16号，请重新输入");
            buyblue=sc.nextInt();
        }

        //打印购买的红色球数组
        System.out.println("你购买的红球号码为：");
        for (int a : buyred) {
            System.out.print(a+"\t");
        }

        //打印购买的蓝色球数
        System.out.println("你购买的篮球号码为："+buyblue);
        System.out.println();


        //自动生成的红色球数组，开奖
        System.out.println("红球号码为");
        for (int n : red) {
            Thread.sleep(1000);
            System.out.print(n+"\t");
        }
        System.out.println();
        //打印自动生成的篮球号码
        int blue=rd.nextInt(16)+1;
        System.out.println("篮球号码为");
        System.out.println(blue);

        //判断是否中奖
        int count=0;
        for (int s=0;s<6;s++){
            for (int q=0;q<=s;q++){

                if (buyred[s]==red[q]){
                   count+=1;
                    }
                }
        }
        //System.out.println(count);

        if (Arrays.equals(red,buyred) && blue==buyblue){
            System.out.println("恭喜你，中一等奖！！！！！");
        }else if (Arrays.equals(red,buyred)){
            System.out.println("恭喜你，中二等奖！！！！");
        }else if (count==5 && blue==buyblue){
            System.out.println("恭喜你，中三等奖！！！");
        }else if ((count==5) || (count==4 && blue==buyblue)){
            System.out.println("恭喜你，中四等奖！！");
        }else if (count==4 || (count==3 && blue==buyblue)){
            System.out.println("恭喜你，中五等奖！");
        }else if ((count==2 && blue==buyblue) || (count==1 && blue==buyblue) || (blue==buyblue)){
            System.out.println("恭喜你，中六等奖！");
        }else{
            System.out.println("很遗憾，你没有中奖");
        }
    }
}

总结

这一周学习的内容是java的基础阶段，高楼平地起，虽然java基础并不算太难，但是却是入门的一课，也是之后学习的高级和面向对象的基础，其中我觉得比较混的主要是循环的嵌套，并加上了数组的循环。所以更应该时时查阅复习，做到温故而知新。

  //System.out.println(count);

    if (Arrays.equals(red,buyred) && blue==buyblue){
        System.out.println("恭喜你，中一等奖！！！！！");
    }else if (Arrays.equals(red,buyred)){
        System.out.println("恭喜你，中二等奖！！！！");
    }else if (count==5 && blue==buyblue){
        System.out.println("恭喜你，中三等奖！！！");
    }else if ((count==5) || (count==4 && blue==buyblue)){
        System.out.println("恭喜你，中四等奖！！");
    }else if (count==4 || (count==3 && blue==buyblue)){
        System.out.println("恭喜你，中五等奖！");
    }else if ((count==2 && blue==buyblue) || (count==1 && blue==buyblue) || (blue==buyblue)){
        System.out.println("恭喜你，中六等奖！");
    }else{
        System.out.println("很遗憾，你没有中奖");
    }
}

}


## 总结

这一周学习的内容是java的基础阶段，高楼平地起，虽然java基础并不算太难，但是却是入门的一课，也是之后学习的高级和面向对象的基础，其中我觉得比较混的主要是循环的嵌套，并加上了数组的循环。所以更应该时时查阅复习，做到温故而知新。

m0_68481241

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
3
评论
华清远见重庆中心—Java基础阶段技术总结

Java能做什么java的分类- JavaME - JavaSE - JavaEE JavaME称为Java微型版，用于开发移动应用，早起塞班系统中会使用，如今已经被淘汰JavaSE称为Java标准版，是Java的核心和基础，也是JavaME和JavaEE的核心，可以用于开发桌面端成都。如IDEA就是用java开发JavaEE称为Java企业版，用于开发WEB应用。Java的流行全靠JavaEE。WEB应用如门户网站、电子商务、电子政务等服务器都是JavaEE实现。
复制链接

扫一扫