java开发工程师入门第一阶段(01-java基础)

已于 2022-03-01 16:20:47 修改
阅读量182 收藏 1
点赞数 1
分类专栏： java基础 文章标签： java java-ee
于 2022-02-24 20:25:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/javaLkx/article/details/123120064
版权

文章目录

一.阶段学习路径

在这里插入图片描述

二.基础语法Basic

1.基础环境配置

1.1 安装JDK

JDK:Java开发工具包，我们使用的版本是1.8
注意:一台PC上可以安装多个JDK,具体环境变量配置哪个JDK,哪个就生效

1.2 环境变量的配置

JAVA_HOME : 配置的是JDK安装的目录
Path : 配置的是JDK的bin目录,不新建的
CLASS_PATH:配置的是JDK的lib目录
win+R键,在运行窗口输入cmd
验证命令为 : java -version 出现JDK版本号即为成功

1.3 开发工具

eclipse IDEA
注意1：开发工具无需纠结，重要的是编程的思路，对于工具而言，选一个自己喜欢的就好，重要的是提高这个自己常用软件的熟练度(快捷键 字体设置 配置JDK…面向百度进行开发)
注意2：大家在安装的时候，不要选择C盘系统盘，而且路径中不要出现中文或者空格等等其他特殊符号，因为会出现一些未知的问题

1.4 JDK JRE JVM

JDK:Java开发工具包(Java Development Kit)–开发的最小单位
JRE:Java运行时环境(Java Runtime Environment)–运行的最小单位
JVM:Java虚拟机(Java Virtual Machine)–负责加载并运行.class字节码文件
1.运行过程: 我们编写的源码是.java为后缀的,通过编译生成的是.class字节码文件,交给JVM来执行
2.跨平台: 只要在不同的操作系统上安装对应的JVM,就可以实现跨平台:一份代码 处处运行
在这里插入图片描述

2.语法基础

2.1 关键字

50个全小写的单词,在Java有特殊的意义,还包含2个保留字const goto
在这里插入图片描述

2.2 标识符

字母 数字 下划线 美元符号组成,不能以数字开头,区分大小写,关键字+(true false null)也不可以用作标识符,见名知意
UpperCamelCase大驼峰命名：
每个单词的首字母都要大写，比如类名：HelloWorld类名: Upper驼峰命名:每一个单词的首字母都要大写
LowerCamelCase小驼峰命名：
从第二个单词的首字母才开始大写，比如:方法名：nextLine() 变量名：deptName

2.3 注释

单行注释 //
多行注释 / * * /
文档注释: /** */
还可以添加一些额外的信息:作者 时间 版本 参数 返回值类型
注释可以注释内容,被注释的内容不执行,所以我们可以利用注释手段对进行分段代码测试

2.4 变量

1.成员变量:类里方法外,类消失,成员变量才会消失
成员有自己的默认值,可以不手动赋值
2. 局部变量:方法里/代码块里,当局部代码结束,局部变量也随之释放
3. 局部变量使用的时候,必须赋值,可以
声明的时候并且赋值 Cat cat = new Cat();
先声明再赋值 Cat cat; cat = new Cat();
注意:基本类型保存的是值,引用类型保存的是地址值
4.变量的就近原则:离谁近 就使用谁
4.1如果想指定本类的成员变量,使用this.变量名来指定
4.2如果想指定父类的成员变量,使用super.变量名来指定

2.5 八大基本类型

在这里插入图片描述

2.6 字面值规则

1.整数类型的字面值类型是int
2. 浮点类型的字面值类型是double
3. byte short char 三种比int小的类型,可以在范围内直接赋值
4. 三种字面值后缀 : L D F
5. 三种字面值前缀: 0b-二进制 0-八进制 0x-十六进制
6. 练习:查看字面值前缀

package cn.tedu.basic;
/*本类用于测试字面值前缀*/
public class TestTypePre {
    public static void main(String[] args) {
        System.out.println(100);//100,十进制,10的平方
        System.out.println(0b100);//4,二进制,2的平方
        System.out.println(0100);//64,八进制,8的平方
        System.out.println(0x100);//256,十六进制,16的平方

        System.out.println(101);//101=100+1,十进制,10的平方+10的0次方
        System.out.println(0b110);//6=4+2,二进制,2的平方+2的1次方
        System.out.println(0111);//73=64+8+1,八进制,8的平方+8的1次方+8的0次方
        System.out.println(0x101);//257=256+1,十六进制,16的平方+16的0次方
    }
}

2.7 运算规则

1.运算结果的数据类型与参与运算的最大类型保持一致 int+int->int double/int->double
2.整数运算会出现溢出的现象,一旦溢出,数据就不正确了(光年案例)
3.byte short char三种比int小的类型,运算的时候需要先自动提升int类型,再参与运算
4.浮点数的特殊值:Infinity NaN
5.浮点数运算不精确的问题：解决方案：BigDecimal
注意1：不能使用double类型参数的构造方法，需要使用String类型的构造函数，否则还会出现不精确的问题
注意2：除法运算时，如果出现除不尽的现象还会报错，所以需要指定保留位数与舍入方式(四舍五入)

2.8 类型转换

口诀:小转大,直接转 大转小,强制转 浮变整,小数没
1.注意:布尔类型不参与类型转换
2.注意:基本类型之间能否转换,不取决于字节数,字节数只能做参考,取决于类型的取值范围
3.注意:我们这里所说的是基本类型之间的转换,引用类型之间的转换取决于是否有继承关系
比如:你可以说小猫是小动物,但是不能说小猫是小汽车,不然后面的这种错误的情况会报:类型转换异常
在这里插入图片描述
4.练习题:类型之间的转换与字面值规则

package cn.tedu.basic;
/*本类用于测试类型转换
* 1.byte1--short2--char2--int4--long8--float4--double8
* */
public class TestTypeChange {
    public static void main(String[] args) {
        byte a = 10;
        short b = a;//不会报错,小转大

        int c = 1;
        long d = c;//不会报错,小转大

        float f = 3.14f;
        double e = f;//不会报错,小转大

        long g = 97525205273520L;
        float h = g;//不会报错,小转大

        char i = 'a';
        int j = i;//不会报错,小转大
        System.out.println(j);//97

        int a1 = 1;
        byte b1 = 2;
        //byte c1 = a1 + b1;//会报错,大转小
        byte c1 = (byte) (a1 + b1);//强制类型转换就不会报错了
        System.out.println(c1);//3

        byte d1 = (byte) 128;
        System.out.println(d1);//-128,强制类型转换要在小类型的范围内转,否则会发生数据溢出的问题

        short e1 = 'a';
        char f1 = 120;
        System.out.println(e1);//97
        System.out.println(f1);//'x'

        float h1 = 32874.456f;
        int i1 = (int) h1;
        System.out.println(i1);//32874
    }
}

2.9 运算符

1.普通的四则运算符 + - * / ,普通的四则运算,并不能直接改变变量本身的值,除非 i = i*10+8
2.取余 % 6%4=2 6%3=0(余数为0表示整除)
3.自增自减运算符
1)可以改变变量本身的值
2)前缀式: 符号在前,先改变变量本身的值(+1/-1),再使用(打印/参与运算…)
3)后缀式: 符号在后,先使用(打印/参与运算…),再改变变量本身的值(+1/-1)
4)注意:不管是前缀式还是后缀式,一定是会改变变量本身的值,区别在于执行的时机不同
4.比较运算符
4.1比较运算符最终的结果是布尔类型的
4.2== 比较的是左右两边的值是否相等 !=比较的是左右两边的值是否不相等
5.练习题:==比较的练习

package cn.tedu.basic;
/*本类用于测试运算符*/
public class TestOperator {
    public static void main(String[] args) {
        //创建小猫类的对象
        Cat c1 = new Cat();
        Cat c2 = new Cat();
        int[] a1 = {1,2,3};
        int[] a2 = {1,2,3};
        int b1 = 4;
        int b2 = 4;
        boolean f1 = true;
        boolean f2 = true;
        /*==如果比较的是引用类型,比较的值是引用类型变量保存的地址值*/
        System.out.println(c1 == c2);//false
        System.out.println(a1 == a2);//false
        /*==如果比较的是基本类型,比较的值就是字面值,也就是这个变量具体存的那个数*/
        System.out.println(b1 == b2);//true
        System.out.println(f1 == f2);//true
    }
}
class Cat{
    String name;
    int age;

    public void bark(){
        System.out.println("喵喵叫");
    }
}

6.逻辑运算符
双与/短路与/&& :
判断逻辑与&一致,增加了短路的功能全真才真,有假则假
双或/短路或/|| :
判断逻辑与|一致,增加了短路的功能全假才假,有真则真
注意:我们这里所说的短路,是指在某些情况下,表达式后半部分就不用计算了,因为我们已经知道了结果,也就是被短路了,短路可以提高程序的性能,但是短路不一定会用到
7. 三目运算符: 1 ? 2 : 3; 1是表达式,1真取2,1假取3
8. 复合赋值运算符:+= -= *= /=是一种简写的形式,比较方便,运算时会自动进行类型转换
9. 赋值运算符: = ,右边给左边
10. 拼接功能:+
11. 运算符 : 主要参与的是二进制的运算
&与:全真才真
| 或:全假才假
^异或:相同为0 不同为1
~ 非: 非0为1,非1为0
12. 优先级控制:如果表达式的运算比较复杂,需要控制优先级,可以使用小括号
13. 拓展:instanceof

2.10 流程控制

1.顺序结构

​ 顺序结构中的代码会按照顺序一行一行向下执行所有的代码语句,可以用来进行输入 输出 计算等的操作
但顺序结构不可以完成先做判断,再做选择的流程

2.分支结构
2.1 单分支结构
if(判断条件){
            如果判断条件的结果为true,就执行此处代码,不符合条件,此处跳过
 }
2.2 多分支结构
if(判断条件){
    如果判断条件的结果为true,就执行此处的代码
}else{
    如果不符合条件,执行else处的代码
}
2.3 嵌套分支结构
if(判断条件1){
    符合判断条件1,执行此处代码,不符合,继续向下判断
}else if(判断条件2){
    符合判断条件2,执行此处代码,不符合,继续向下判断
}else if(判断条件3){
    符合判断条件3,执行此处代码,不符合,继续向下判断
}else{
    保底选项,以上条件均不符合的情况下,执行此处代码
}
2.4 练习:
package cn.tedu.basic;

import java.util.Scanner;

/*本类用于复习分支结构*/
public class TestIf {
    public static void main(String[] args) {
        //1.提示并接收用户输入的月份
        System.out.println("请输入您要测试的月份:");
        int month = new Scanner(System.in).nextInt();

        //2.对用户输入的数据进行判断
        if(month<=0 || month >12){
            System.out.println("您输入的数据不正确!");
        }else{
            //3.如果用户输入的数据正确,我们就进行季节的判断
            if(month >=3 && month <=5){
                System.out.println(month+"月是春天");
            }else if(month >=6 && month <=8){
                System.out.println(month+"月是夏天");
            }else if(month >=9 && month<=11){
                System.out.println(month+"月是秋天");
            }else{
                System.out.println("冬天就要来啦,春天还会远吗?");
            }
        }
    }
}
3.选择结构
switch (变量名){
            case value1 : 操作1;break;//可选
            case value2 : 操作2;break;//可选
            case value3 : 操作3;break;//可选
            case value4 : 操作4;break;//可选
            default:保底选项;//可选
        }
3.1小括号中变量支持的类型:

​ byte short char int String enum 与4个基本类型对应的包装类
​ 注意: 如果配置了default默认选项,而且没有任何的case被匹配到,就会执行default这个“保底选项”
​ case的个数 是否加break 是否加default全部都是可选的,根据自己的具体业务做决定
​ 小括号中变量的类型必须与case后value的类型一致
​ 执行顺序:先拿着变量的值,依次与每个case后的值做比较,如果相等,就执行case后的语句
若这个case后没有break,就会继续向下执行下一个case,如果一直没有遇到break,就会发生穿透现象,包括default

4.循环结构

可以帮我们多次重复的做某一件事

4.1for循环
for(开始条件;循环条件;更改条件){
		如果符合循环条件,就会执行循环体里的内容
}

注意1：写法小窍门：从哪开始 到哪结束 循环变量如何变化
注意2：for循环能够执行多少次，取决于循环变量可以取到几个值

4.2嵌套for循环

外层循环控制的是轮数，内层循环控制的是每一轮中执行的次数
对于图形而言，外层循环控制的是行数，内层循环控制的是列数

for(开始条件;循环条件;更改条件){//外层循环
		for(开始条件;循环条件;更改条件){//内层循环
				循环体
		}
}

注意:外层循环控制的是行数,内层循环控制的是列数
注意:外层循环控制的是轮数,内层循环控制的是在这一轮中执行的次数

4.3高效for循环
for(遍历到的元素的类型 遍历到的元素的名字 ：要遍历的数组/集合名){
		循环体
}

优点：写法简单，效率高
缺点：只能从头到尾的遍历数据，不能进行步长的选择

4.4while循环
while(判断条件){
		如果符合判断条件,继续循环
}

注意:常用来完成死循环,但死循环必须设置出口!
练习题:while循环练习

package cn.tedu.basic;
/*本类用于复习while循环*/
public class TestWhile {
    public static void main(String[] args) {
        //需求:通过while循环打印10次"小可爱们中午好~"
        //f1();
        //需求:通过while循环打印1 2 3 ... 10
        //f2();
        //需求:通过while循环打印1 3 5 7... 99
        f3();
        //需求:通过while计算1+2+3+4...+10
        f4();
        //需求:通过while计算2+4+6+8...+100
        f5();
    }

    private static void f5() {
        //需求:通过while计算2+4+6+8...+100
        int i = 2;//定义循环变量i用来控制循环
        int sum = 0;//定义变量用来保存累加的结果
        while (i<=100){
            //sum += i;
            sum = sum + i;//累加
            //i += 2;
            i = i + 2;//循环变量i每次+2
        }
        System.out.println("2到100所有偶数的和为:"+sum);
    }

    private static void f4() {
        //需求:通过while计算1+2+3+4...+10
        int i = 1;//用于控制循环,相当于循环变量
        int sum = 0;//用于保存求和累加的结果
        while(i<=10){
            sum = sum + i;
            i++;
        }
        System.out.println("1到10累加的结果为:"+sum);
    }

    private static void f3() {
        //需求:通过while循环打印1 3 5 7... 99
        int sum = 1;
        while(sum <100){
            System.out.println(sum);
            //sum = sum +2;
            sum += 2;
        }
    }

    private static void f2() {
        //需求:通过while循环打印1 2 3 ... 10
        //1.定义一个变量来控制执行的次数
        int i = 1;
        while(i<=10){
            System.out.println(i);
            i++;
        }
    }

    private static void f1() {
        //需求:通过while循环打印10次"小可爱们中午好~"
        //1.定义一个变量用来控制执行的次数
        int count = 1;
        while(count <= 10){
            System.out.println("小可爱们中午好~");
            count++;//注意count的值需要自增,否则还是一个死循环
        }
    }
}
4.5do-while循环

do-while循环一定会执行一次，然后再判断，如果符合条件，再执行后面的循环

do{
		循环体
}while(判断条件);

循环之间的比较

  1. 如果明确知道循环的次数/需要设置循环变量的变化情况时–使用for循环
  2. 如果想写死循环–while(true){}
  3. 如果需要先执行一次，再做判断–do-while循环
  4. 循环之间是可以互相替换的，但是最好使用比较合适的循环结构

2.11 方法

1.格式: 修饰符 返回值类型 方法名(参数列表){ 方法体 }
2.如何确定我们要调用哪个方法呢?方法名+参数列表
3.一个方法被调用,就会执行这个方法的功能,执行完毕就返回到方法被调用的位置,在第几行调用，程序就返回到第几行继续向下执行
如果这个方法有返回值,我们有两种选择:
3.1选择只执行功能,不接收返回值,不再继续使用这个方法的结果
3.2选择在方法调用的位置接收这个方法的返回值,接收到的返回值可以在方法外继续使用
在这里插入图片描述
4.方法的重载:
在同一个类中出现多个方法名相同,但参数列表不同的方法
注意:方法是否构成重载,取决于参数列表中参数的个数与参数的类型,与参数的名字无关
重载的意义: 重载不是为了程序员方便,而是为了方便外界调用这个名字的方法时，不管传入什么类型的参数,都可以匹配到对应的方法来执行,程序会更加的灵活
5.方法的传值 : 如果方法的参数类型是基本类型,传入的是实际的字面值,如果是引用类型,传入的是地址值
形参:形式意义上的参数,比如方法参数列表的参数名,光看参数名是无法确定这个变量的值是多少的
实参:实际意义上的参数,比如我们的局部变量,比如成员变量,比如调用方法时传入的数字
6.方法的重写: 子类继承了父类以后,想要在不改变父类代码的情况下,实现功能的修改与拓展
重写遵循的规则:两同 两小 一大
一大: 子类方法的修饰符权限 >= 父类方法的修饰符权限
两同: 方法名与参数列表与父类方法保持一致
两小: 子类方法的返回值类型 <= 父类方法的返回值类型,注意:这里的<=说的是继承关系,不是值的大小
子类方法抛出的异常类型 <= 父类方法抛出的异常类型
7.四种权限修饰符
在这里插入图片描述
8.练习题:方法调用的顺序

package cn.tedu.basic;
/*本类用于测试方法的调用*/
public class MethodDemo {
    //1.创建程序的入口函数main()
    public static void main(String[] args) {
        System.out.println("main() start...");
        m1();
        System.out.println("main() stop...");
        int a =5;
        System.out.println(a);
    }

    //2.创建m1()
    private static void m1() {
        System.out.println("m1() start...");
        m2();
        System.out.println("m1() stop...");
    }
    private static void m2() {
        System.out.println("m2() start...");
    }
}

2.12 数组

1.数组的创建方式:
静态创建 int[] a = {1,2,3,4,5};
静态创建 int[] a = new int[]{1,2,3,4,5};
动态创建 int[] a = new int[5]; 后续可以动态的给数组中的元素赋值
注意:不管是什么样的创建方式,都需要指定数组的类型与长度
2.我们可以通过数组的下标来操作数组中的元素
数组下标从0开始,最大下标是数组的长度-1,如果访问到了不是这个数组的下标,会出现数组下标越界异常
比如:a[5]表示的就是数组中的第6个元素
3.数组的长度:数组一旦创建,长度不可改变,长度指的是数组中元素的个数a.length,并且数组的长度允许为0:[ ]
4.数组的创建过程:
4.1根据数组的类型与长度开辟一块连续的内存空间
4.2对数组中的每个元素进行初始化,比如int数组的默认值就是0
4.3生成数组唯一的一个地址值,交给应用类型变量a来保存
4.4后续可以根据数组的下标再来操作数组中的具体元素
注意: 数组名a这个变量,保存的是数组的地址,不是数组中的具体元素
在这里插入图片描述
5.数组的工具类Arrays
5.1 toString(数组名) : 除了char类型的数组以外,其他类型的数组想要查看具体元素,需要使用本方法,否则打印的是地址值
5.2 copyOf(原数组名,新数组的长度) : 用来实现数组的复制 扩容 缩容
如果新数组的长度 > 原数组长度,就扩容,反之,则缩容,如果两者长度一致,就是普通的复制数组
注意:一定是创建了新数组,而不是对原数组的长度做操作

6.数组的遍历
一般习惯使用for循环,循环变量代表的就是数组的下标,从0开始,最大值是a.length-1
7. 冒泡排序 :
外层循环控制比较的轮数,所以循环变量从1到n-1轮,代表的是轮数
内层循环控制的是这一轮中比较的次数,而且是数组中两个相邻元素的比较,所以循环变量代表的是数组的下标
8.练习:

package cn.tedu.basic;
/*本类用于复习数组的操作*/
public class TestArray {
    public static void main(String[] args) {
        //需求1:求出数组中所有元素之和
        //f1();
        //需求2:求出数组中所有元素的最大值
        f2();
    }

    private static void f2() {
        //需求2:求出数组中所有元素的最大值
        //1.定义一个数组
        int[] a = {10,20,98,40,55};
        //2.定义一个变量,用来存储结果,也就是数组中所有元素的最大值
        int max = a[0];//这个位置不能写0,应该是数组中的第一个元素
        //3.遍历数组,依次拿出数组中的每一个元素与之前设定的元素做比较
        for (int i = 0; i < a.length; i++) {
            //4.判断当前遍历到的元素,与max谁大
            if(a[i]>max){//如果当前遍历到的元素比max大
                max = a[i];//就把遍历到的这个元素的值赋值给max
            }
        }
        //5.循环结束,输出数组中最大的值
        System.out.println("数组中的最大值为:"+max);
    }
    private static void f1() {
        //需求1:求出数组中所有元素之和
        //1.定义一个数组
        int[] a = {12,12,22,22,22};
        //2.定义一个变量,用来保存最终求和的结果
        int sum = 0;
        //3.通过数组的遍历,遍历数组中的每一个元素,然后累加
        for (int i = 0; i < a.length; i++) {
            sum = sum + a[i];
        }
        System.out.println("数组累加所有元素之和为:"+sum);
    }
}
@吟游诗人
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java第一阶段学习——建立编程思想
weixin_42357284的博客
04-12 669
Day1 （1）什么是JDK、JRE JDK基本介绍 JDK的全称（Java Development Kit）Java 开发包工具） JDK = JRE + Java的开发工具（Java，javac，javadoc，javap。） JRE基本介绍 JRE（Java Runtime Environment Java运行环境） JRE = JVM + java的核心类库（类） 包括JAVA虚拟机和Java程序所需要的核心类库等，如果要运行一个开发好的Java程序，计算机只需要安装JRE即可 （2）安装
java第一阶段部分面试题
05-30
自己总结的一些java一阶段面试题，重点内容！ 自己总结的一些java一阶段面试题，重点内容！
逻辑控制——JavaSE
m0_61963422的博客
03-17 87
文章目录
Java学习记录 求输入月份，判断该月所处的季节并输出季节
C7WPtVu9的博客
04-03 2139
2021-04-03 要求输入月份，判断该月所处的季节并输出季节（假设：12、1、2 月为冬季，依次类推） 解决思路： 使用switch语句case的穿透效果，当月份为12，1，2时，打印输出为冬季。当月份为3，4，5时，打印输出为夏季。当月份为6，7，8时，打印输出为秋季。 代码如下： import java.util.Scanner; public class Class4_3 { public static void main(String[] args) { int in
【Java】输入一个分钟数，显示其代表了多少年和多少天？
qq_34017390的博客
10-12 2898
package computer; import java.util.Scanner; /* * 给出一个分钟数，显示其代表了多少年和多少天 * 一年按365计算。 * * 一年有365天， * 一天有24小时， * 一小时有60分钟 * 一年由365*24小时 * 一年有365*24*60分钟 * * */ public class First { public static void main(String []args) { System.out.print.
Java零基础入门之Java概述及环境搭建
06-15
本课程是《Java零基础至高级应用》系统课程的第一章，全套课程精细讲解，高级课程超过其他机构30%的课程量，经过我们全套课程系统学习的同学，可轻松从事Java高级工程师或系统架构师岗位，课程提供全套代码笔记其它...
Java从入门到精通.pdf
08-07
十四万字总结，PDF包含了十四个大模块：Java基础知识，数据结构，算法，Java集合框架，Java8新特性，操作系统，网络原理，Java多线程及并发编程，Java的IO...适合小白及Java初中级开发工程师。面试必备.(一直会更新)
JAVA软件工程师_Java入门视频教程
07-10
[第1节] 1.面向对象开发 [第2节] 2.定义类 [第3节] 3.创建对象 [第4节] 4.类成员之成员方法 [第5节] 5.类成员之成员变量 [第6节] 6.构造方法 [第7节] 7.案例：影片播放机 [第8节] 8.小结 [第9节] 1.2.1为什么需要...
java高级软件工程师教程快速入门Zookeeper+dubbo视频教程
11-05
本套课程中，第一阶段深入Zookeeper原理和源码，分析Zookeeper的核心实现，并通过多个应用场景说明，体现出其重要性和广泛的应用性。第二阶段深入Dubbo RPC、SPI等核心功能点，列举多个示例加以应用说明，期望能够...
韩顺平java从入门到精通视频教程(全94讲)学习笔记整理(齐全)-共448页.docx
06-13
java内容介绍 java编程可以分成三个方向： 1、java se (j2se)桌面开发 java中的基础中的基础 2、java ee (j2ee)web开发 3、java me (j2me)手机开发 ...1995 sun正式发布java第一个版本，目前最新是jdk7.0
JAVA第一阶段
weixin_50569525的博客
03-20 118
java基础 遗忘点，难点 1.ASCII码表中，48—0,65—A,97------a,32------空格 2.``System.out.println(–a); System.out.println(a–); 结果是不同的， 3.逻辑与（&）和短路与（&&）的区别：逻辑与的判断方式是： 从左到右依次判断，直到结尾（逻辑全程运算） 短路与的判断方式是: 从左到右依次判断，直到出现false为止将不再判断，直接得到结果为false（短路遇false就停） 4. switch 语句中
面试题一（计算机基础、逻辑）
每天一个前端小知识~
07-14 8488
一、计算机基本概念题 1.下列字符中，ASCII码值最小的是（B） A.a B.A C.x D.Y A是65，a是97 2.内存容量的单位是(A) A. 字节 B. 字长 C. 字 D. 二进制位 3.Excel2000工作簿默认的工作表个数是（C） A.10 B.16 C.3 D.5 4.机器语言由（A）构成的。 A. 二进制代码 B. 十六进制代码 C. 字符代码 D. 汇编语言代码 5.操作系统是一个（A） A. 系统软件 B. 应用软件 C. 工具软件 D. 数据库软件 6.十进制数64对应的八进制
java根据月份判断是哪个季节_java-第十一章-类的无参方法-根据1~12时间的数字判断春夏秋冬按个季节...
weixin_42097967的博客
02-27 987
package本章总结;publicclassA01class{publicStringshowA(){return"该季节为春天";}publicStringshowB(){return"该季节为夏天";}publicStringshowC(){return"该季节为秋天";}publicStringshowD(){return"该季节为冬天";}}pac...
JAVA练习题1（初级基本数据类型、运算符）
赵同学的博客
11-27 1632
JAVA练习题1（初级） 文章目录JAVA练习题1（初级）1.求一光年是多少千米 , 光在真空中传播速度299792458 m/s2.根据天数（46）计算周数和剩余的天数3.已知圆的半径radius= 1.5，求其面积 (Java中π用Math.PI表示)自己给定5个整数，通过编程求出最大值(使用三元运算符)韩梅梅看中两把价格相同的扇子，想挑选一个扇面较大的扇子购买，请你帮她挑选。6.变量a和b的值互换 例如：int a = 10,b=20; 结果：a=20,b=10;7.定义一个变量，是一个三位数，求
java第一阶段知识_Java第一阶段总结
weixin_33296185的博客
02-13 245
前言此篇博客主要针对PTA三次作业做一个总结，也是对自己学习了一个多月的Java做一个小结，学习了Java语言的一些基本用法，初步认识了面向过程和面向对象，了解是一个怎样的过渡过程以及两者的不同之处。一、作业过程总结1.总结三次作业之间的知识迭代关系:第一次作业:Main类中只用了一个主方法去写题目所需要的功能，初步使用输入方法和循环方法；第二次作业:在Main类中除了主方法还写了很多种其他方法，...
【JavaWeb】Java/Java web第一阶段总结
哈哈哈哈哈哈哈
12-19 2984
我的Java学习时间线：<iframe>第一阶段到此结束。以下是这大半年以来所写的一些项目或者工具：1.云打印地址：http://yao2san.com/csh2.新闻与博客地址：http://yao2san.com/yao2an3.文本情感评分地址：http://yao2san.com/nlp4.我们的博客地址：完善中 ** 5.HCI实验室地址：完善中下面是对这差不多10个月的Java学习中
Java基础第一阶段——01_Java语言概述&HelloWorld
雨一直下
11-20 927
Java基础第一阶段——Java语言概述&HelloWorldTags ： Java基础 记得最初在学习Java的时候，也是学习黑马视频，看的毕向东老师的基础视频。印象当中，学习Java基础知识不下3遍，后来反思下，其实走过了不少冤枉路，也“浪费”了不少的时间在这些基础知识上面，本身是知道基础知识的重要性，但是一遍遍的去学习基础知识，总觉得还是“没劲”、“徒劳”。与其这样，倒不如一次性巩固好这些
java第一阶段_java第一阶段总结
weixin_34882814的博客
02-21 138
前言：学习java一个月了，我了解了一些java的发展历史和基本语法，并通过三次作业实践对面向对象的编程思维与面向过程编程思维之间区别有了一点大概的了解。接下来我将通过以下文章总结一下这个月的收获。1.作业过程总结①三次作业之间的知识迭代关系：三次作业的难度依次叠加，从简单到复杂，从纯粹的面向过程思维到OO编程思维的转换。第一次作业，我通过五道题(1 计算税率，2 判断坐标点所在范围，3 电话键盘...
7-1 jmu-java-01入门-第一个pta上java程序
最新发布
09-12
7-1 jmu-java-01入门-第一个pta上Java程序是一个关于学习Java编程的题目。在这个题目中，我们需要编写一个简单的Java程序。 这个程序要求实现一个功能，即能够输出"Hello Java!"这句话。实现这个功能很简单，只需要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值