Java基础及高级学习笔记

于 2024-04-19 16:14:14 发布
阅读量596 收藏 4
点赞数 4
文章标签： java 学习 笔记 jdk
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45157317/article/details/137968662
版权

三、java基础

变量与运算符

java程序结构

程序是由程序块组成{}，数据类型、变量、运算符、控制流语句。

标识符、关键字和保留字

标识符：用来表示一些元素的名字，比如：变量名、类名、包名。

标识符命名规则：1.标识符必须是以字母开头、下划线（_）、数字、或者美元（$）组成

  1. 标识符不能是关键字或者保留字

  2. 标识符中不能有空格

  3. 标识符没有长度限制

    关键字和保留字

https://m.runoob.com/java/java-basic-syntax.html

变量名

变量时用来存储数据的，在程序运行的过程中它的值是可以变化的，变量可以存放一种数据类型的值，变量的数据类型在声明时需要指定。

作用：

​ 1.变量是程序中数据的临时存放场所

​ 2.保存程序运行时用户输入的数据

​ 3.特定的运算结果

变量的声明
/**
 *数据类型 变量名1,变量名2
**/
    String account,password;
变量名的赋值
/** 
* 变量赋值：
 *  第一次给变量赋值叫“初始化”。使用“=”来进行赋值
 *      数据类型 变量名 = 数据值
 *  程序运行时进行变量的数值的更改，叫做“赋值”
 *      数据类型 变量名 = 数据值
 *  变量名的访问：
 *
**/
public static void main(String[] args) {
   
    String sex = "女";
    int age = 18;
    String account = "admin";
    String password = "admin";
    System.out.print(age);
}

常量

在程序运行中往往会存在变量值不会变化的情况，比如圆周率，那么这些值不允许发生变化的变量就会叫常量。

在Java中，常量用final来表示，他也是有数据类型的，语法：

​ final 数据类型 常量名 = 初始值

注意点：1.常量在声明的时候必须初始化 2.常量在初始化后值不能再更改，否则会引起错误。

 final double PI = 3.14;
    System.out.print(PI);

基本数据类型

在这里插入图片描述

整型

byte 字节型 1个字节（8位二进制） -128~127

short 短整型 2个字节（16位二进制） -2^15 ~ 2^15-1

int 整型 4个字节（32位二进制） -2^31 ~ 2^31-1

long 长整型 8个字节（64位二进制） -263~263-1

浮点型

float 单精度 4个字节

double 双精度 8个字节

十进制：3.14

科学计数法：3.14e2

double d = 12345.6;
float f = 20.3F;

注意：1.带小数的数据默认是double,而非float

​ 2.定义float数据需要后面加“f”，“F”

​ 3.定义长整型数据，可以后面加“l”,“L”

字符数据类型

字符数据类型用于存放单个字符，每个字符占用2个字节，一个字符型数据由单引号括起来，使用char来说明数据类型。

char a = 'a';
字符及其含义

‘a’:字母a

‘中’：汉字中

‘\n’:转义字符表示：换行

‘\t’:tab空格

‘\r’:回车

‘\b’:代表一次退格

//    换行
    System.out.print('\n');
//    斜杠
    System.out.print('\\');
//    单双引号
    System.out.print('\"');

布尔数据类型

boolean，只有两个值：true、false，全部都是小写。

True，False

 boolean idOK = true;
    boolean flag;
    flag = true;

数据类型的转换

自动类型转换：1.两种类型彼此兼容 2.目标类型的却只范围要大于原类型

byte/short/char—>int–>long–>float–>double

强制类型转换：变量= （目标类型） 值

//自动转换
    int i1 = 12;
    int i2 = 45;
    double d1 =  (i1 + i2)*1.0;
    System.out.println(d1);

//    强制转换
    byte b;
    int c = 0;
    float i = 2.8f;
    System.out.println((int)i);
    b =(byte)c;

运算符

算术运算符和表达式

+：加运算符

-：减运算符

*：乘运算符

/：除运算符

%：取模运算符

++：自增

–：自减

+：字符串的拼接

/**
 * @Author:sng
 * @Time:2023/7/24 14:04
 * @File:demo02
 * @Project_Name:JavaProject
 * @Product_Name:IntelliJ IDEA
 **/
public class demo02 {
   
    public static void main(String[] args) {
   
//        变量初始化
        int i = 0;
        int a;
//        实现a和i的连接，i进行自增，最终讲值赋值给a
        /**
         * 变量名++：先用原来的值参与运算，然后再给自己加1
         */
        a = i++;
//        i = i + 1,i = 1
        System.out.println(i);
        System.out.println(a);
//        a = ++i
        /**
         * ++变量名：先将自己加1，然后再参与运算
         */
        a = ++i;
//        i = i + 1, i = 2
        System.out.println(i);
        System.out.println(a);
//        2 % 3 = 2, 2 + 1 = 3,i = 3
        System.out.println(i++ % 3);
//        i = 3; i = i + 1 ,i = 4, 4 % 3 = 1
        System.out.println(++i % 3);

        int m = 0;
        int b;
        b = m--;
        System.out.println("m:"+m);
        System.out.println("b:"+b);

        b = --m;
        System.out.println("m:"+m);
        System.out.println("b:"+b);
    }
}

赋值运算符和表达式

=：赋值运算符

+=：加简捷赋值运算符

-=：减简捷赋值运算符

*=：乘简捷赋值运算符

/=：除简捷赋值运算符

%=：取模简捷赋值运算符

/**
 * @Author:sng
 * @Time:2023/7/24 14:24
 * @File:demo03
 * @Project_Name:JavaProject
 * @Product_Name:IntelliJ IDEA
 **/
public class demo03 {
   
    public static void main(String[] args) {
   
        int i = 10;
//      i = i + 8; i = 18
        i  += 8;

        i -= 8;

        i *= 8;

        i %= 8;
        System.out.println(i);
    }
}

关系运算符和表达式

/**
 * @Author:sng
 * @Time:2023/7/24 14:28
 * @File:demo04
 * @Project_Name:JavaProject
 * @Product_Name:IntelliJ IDEA
 **/
public class demo04 {
   
    public static void main(String[] args) {
   
        /**
         * 常见的比较运算符：> <  >= <= == !=
         */
        int i = 10;
        int j = 16;
        boolean b = i != j;
        boolean equal = i == j;
        System.out.println(b);
    }

}

逻辑运算符和表达式

&&：与运算符

||：或运算符

！：非运算符

/**
 * @Author:sng
 * @Time:2023/7/24 14:36
 * @File:demo05
 * @Project_Name:JavaProject
 * @Product_Name:IntelliJ IDEA
 **/
public class demo05 {
   
    public static void main(String[] args) {
   
        int a = 10;
        int b = 20;
        int c = 30;
       /**
        boolean flag = a>b && ++b > c;//两边都不成立：false
        boolean flag1 = a<b && ++b > c;//左边成立，右边不成立：false
        boolean flag2 = a<b && ++b < c;//两边成立：true
        boolean flag3 = a>b & ++b > c;//两边不成立：false
        boolean flag4 = a < b & ++b > c;//左边成立，右边不成立：false
        System.out.println(b);
        System.out.println(flag4);
        **/
       boolean flag = a<b || ++b > c;//左边成立，右边不成立：true
        boolean flag1 = a>b || ++b < c;//左边不成立，右边成立：true
        boolean flag2 = a>b | ++b < c;
       System.out.println(flag2);


    }
}

三目条件运算符

表达式 ？ 表达式2：表达式3

/**
 * @Author:sng
 * @Time:2023/7/24 14:50
 * @File:demo06
 * @Project_Name:JavaProject
 * @Product_Name:IntelliJ IDEA
 **/
public class demo06 {
   
    public static void main(String[] args) {
   
        int a = 10;
        int b = 20;
        /**
         * 当表达式1：a<b,成立的时候，会选择“？”后的第一个作为结果输出，如果不成立，则会选择“？”后面的第二个作为结果输出
         */
        boolean flag = a > b?true:false;
        System.out.println(flag);
    }
}

运算符优先级

/**
 * @Author:sng
 * @Time:2023/7/24 14:55
 * @File:demo07
 * @Project_Name:JavaProject
 * @Product_Name:IntelliJ IDEA
 **/
public class demo07 {
   
    public static void main(String[] args) {
   
        int a = 10;
        int b = 20;
        int c = 30;
//        int m = (a + b) * c;
//        int h =  b / c * a ;
//        System.out.println(h);
        /**
         * 按操作数多少分为：一元操作符、二元~~、三元操作符
         * 算数运算符>关系运算符>逻辑运算符>赋值运算符
         */
        boolean m = c > a && b < a ;
        System.out.println(m);

    }
}

编程题：

1.已知a,b都是整型变量，写出将a,b两个变量中的值互换的程序。

2.给定一个0~1000的整数，求各位数的和。例如345=3+4+5=12

3.华氏温度和摄氏温度互相转换

4.给定一个任意的大写字母A~Z，转换为小写字母。

流程控制语句

分支（选择）结构

if语句

在这里插入图片描述

if语句的结构：

（单一）
if(表达式){
   
    执行语句块；
}
表达式是true的时候才会执行语句块。

在这里插入图片描述

二选一

if(表达式){
   
    语句块1
}else{
   
    语句块2
}

多选

if(表达式1){
   
    语句块1
}else if(表达式2){
   
    语句块2
}....
    else{
   
        语句块n(代表的是除去以上所有的情况外)
    }

public class demo01 {
   
    public static void main(String[] args) {
   
        int x = 0;
        /**
         * 单一条件
         */
        /**
        if (x != 1){
//            x != 1:true
            System.out.println("x的值为1");
        }
//        无论表达式是否为true，该语句都会执行
        System.out.println("x的值不为1");
         **/


        /**
         * 二选一：
         *  三目条件运算符：表达式？表达式1：表达式2
         */
        if (x != 1){
   
//            表达式结果为true，就会执行第一个语句块
            System.out.println("x的值为1");
        }else{
   
//            表达式结果为true的时候，第二个语句块不执行，结果为flase的时候才执行
            System.out.println("x的值不为1");
        }


        int i = 89;
        /**
         * 多选
         */
        if (i <= 100 && i >= 90){
   
            System.out.println("成绩是A");
        }else if (i>=80){
   
            System.out.println("成绩是B");
        }else {
   
            System.out.println("成绩是C");
        }
    }
}
switch

switch语句是从多种情况中选择一个条件（事件）执行。

结构：

switch(表达式){
   
    case 事件名:
        语句块;
        [break]
    ...
    default:
        语句块
}

注意：

​ 1.表达式的类型只能是byte、short、char、int

​ 2.case语句只是一个标号语句，只确定程序的入口

​ 3.事件名只能是常量或者常数，不可以是变量，而且不能重复

​ 4.break是一个可选项，用来结束switch语句的。

public class demo02 {
   
    public static void main(String[] args) {
   
        int n = 1;
        int result;
//        byte、short、char、int
        switch (n){
   
            case 1:
                System.out.println("Block A");
                result = n;
                break;
            case 2:
                System.out.println("Block B");
                result = n * n;
                break;
            case 3:
                System.out.println("Block C");
                result = n * n * n;
                break;
            default:
                System.out.println("Block D");
                result = 0;
                break;
        }
        System.out.println(result);
    }
}
/**
将case语句后的值和表达式的值比较，若相等则从该case语句向下执行；如果没有break语句，则一直执行到switch语句的结束，如果遇到break语句，则结束switch语句的执行
**/

练习题

public class demo03 {
   
    public static void main(String[] args) {
   
        /**
         * 使用switch语句实现百分之成绩到成绩等级的转换
         * 总分100，转换成满分为10，9分为A，8：B；7：C；6：D；其余为E
         * 转换：100/10
         */
        int score = 9;
        /**
         * 虽然switch只能输入int。。。。类型数据，但是只要结果为此类型也是可以的
         */
        switch (score / 10){
   
            case 10:
            case 9:
                System.out.println("成绩等级为A");
                break;
            case 8:
                System.out.println("成绩等级为B");
                break;
            case 7:
                System.out.println("成绩等级为C");
                break;
            case 6:
                System.out.println("成绩等级为D");
                break;
            default:
                System.out.println("成绩等级为E");
                break;
        }
    }
}

循环结构

while语句
while(循环条件){
   
    循环体；
}
image-20230725100711749

while语句的代码执行过程：

首先判断循环条件，如果循环条件为true，则执行循环体的代码，然后再判断循环条件，直到循环条件为false的时候，才会停止。

public class demo04 {
   
    public static void main(String[] args) {
   
        int i = 1;
        /**
        while (i <= 3){
//            循环体
            System.out.println(i);
            i++;
        }
         **/
        /**
         * while的括号中，也就是循环条件的数据类型为布尔类型，成立及执行，不成立就退出
         */
        while (i<3){
   
            i++;
            System.out.println(i);
        }
    }
}

练习题：

public class practice02 {
   
    public static void main(String[] args) {
   
        /**
         * 计算1~1000的奇数和
         */
        int i = 1;
        int sum = 0;
        while (i <= 1000){
   
            if (i%2 != 0){
   
                sum += i;//sum = sum + i;
            }
            i++;
        }
        System.out.println(sum);
    }
}



public class practice01 {
   
    public static void main(String[] args) {
   
        /**
         * 计算1~10的和:55
         */
        int i = 1;
        int sum = 0;
        while (i <= 10){
   
            sum = sum + i;
            i++;
        }
        System.out.println(sum);
    }
}
do…while语句

结构：

do{
   
    循环体；
}while(循环条件);
image-20230725104055767 
/**
 * @Author:sng
 * @Time:2023/7/25 10:41
 * @File:demo05
 * @Project_Name:JavaProject
 * @Product_Name:IntelliJ IDEA
 **/
public class demo05 {
   
    public static void main(String[] args) {
   
        /**
         * 使用do..while实现求和：1~1000的奇数
         */
        int i = 1;
        int sum = 0;
        do{
   
            if (i%2 != 0){
   
                sum += i;
            }
            i++;
        }while (i <= 1000);
        System.out.println(sum);
    }
}

do…while的执行流程：

首先执行do里面的循环体，再去判断循环条件，循环条件为true的时候去执行循环体，直到循环条件为false，停止。

for语句

结构：

for(表达式1;表达式2；表达式3){
   
    循环体
}
image-20230725105144127

表达式1：用于初始化，一般书写变量初始化的代码（int a = 0）,它在for循环里面只会执行一次

表达式2：循环条件，要求必须为布尔类型，如果该条件为空，默认为true

表达式3：迭代语句，是指循环变量变化的语句，一般都是（i++）

/**
 * @Author:sng
 * @Time:2023/7/25 10:55
 * @File:demo06
 * @Project_Name:JavaProject
 * @Product_Name:IntelliJ IDEA
 **/
public class demo06 {
   
    public static void main(String[] args) {
   
        for (int x = 1;x < 10;x++){
   
            System.out.println(x);
        }
    }
}

练习题：

/**
 * @Author:sng
 * @Time:2023/7/25 10:56
 * @File:practice03
 * @Project_Name:JavaProject
 * @Product_Name:IntelliJ IDEA
 **/
public class practice03 {
   
    public static void main(String[] args) {
   
        /**
         * 使用for循环语句实现求和：1~1000的所有奇数
         */
        int sum = 0;
        for (int i = 1;i <= 1000;i++){
   
            if (i%2 != 0){
   
                sum += i;
            }
        }
        System.out.println(sum);
    }
}

数组

数组是一个或者多个相同类型的数据按照一定的顺序组合成的一种数据类型。

根据数组的维度可以将数组分为：一维数组、二维数组、三维数组

一维数组

数组的声明

语法：数据类型[] 数组名 或者 数据类型 数组名[]

image-20230725151015655
数组的创建
1.静态方式创建

语法：数据类型[] 数组名 = {数组元素1，数组元素2…数组元素n}

2.动态方式创建

语法：数据类型[] 数组名 = new 数据类型[数组长度]

数组的初始化
1.数组元素的默认值

数组元素是具有默认值的，对于数字类型，默认值是0，对于字符类型，默认值是’\u0000’，对于布尔类型，默认值是false,对于字符串型，默认值是null。

/**
 * @Author:sng
 * @Time:2023/7/25 15:05
 * @File:demo07
 * @Project_Name:JavaProject
 * @Product_Name:IntelliJ IDEA
 **/
public class demo07 {
   
    public static void main(String[] args) {
   
        char list[] = new char[3];
        System.out.println(list[0]);
        String[] lists = {
   "张三","李四","王五","赵六"};
        System.out.println(lists.length);

        int a[] = new int[5];
        //如果是数组，index（索引）是从0开始的
        System.out.println(a[4]);
        //默认是null
        String s[] = new String[4];
        System.out.println(s[0]);
        //默认是false
        boolean b[] = new boolean[3];
        System.out.println(b[0]);
    }
}
2.改变数组元素的默认值

如果数组元素的默认值不满足我们的实际需要，那么我们可以在构建数组的过程中指定数组元素的全部初始值，这个过程也叫数组的初始化。

/**
 * @Author:sng
 * @Time:2023/7/25 15:25
 * @File:demo08
 * @Project_Name:JavaProject
 * @Product_Name:IntelliJ IDEA
 **/
public class demo08 {
   
    public static void main(String[] args) {
   
        int a[]={
   1,2,3,4,5};
        int b[] = new int[]{
   1,2,3};
        System.out.println(b.length);
        System.out.
最低0.47元/天 解锁文章
计算机设计（软件、大数据）
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java高级编程学习
weixin_43892090的博客
01-09 1034
目录 类变量/静态变量 Main方法 代码块 类的加载 单例设计模式 Final关键字 抽象类 模板设计模式 1.9日学习笔记 类变量/静态变量 （jdk8以后，静态变量存放在堆里这个类对应的class对象最后，jdk8以前，静态变量存放在方法区） 类变量也叫静态变量/属性，是该类所有对象共享的变量，任何一个该类对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改他时，修改的也是同一个变量。 static类变量，在类加载的时候就生成了。（new的时候加载）即使没有创
Java高阶学习
xintianlife的博客
03-09 678
一、JVM 1.方法区 作用：存放加载的类信息，常量，静态变量，JIT编译后的代码数据。 GC：会OOM，存在垃圾回收，但回收效率低，主要针对常量池的回收和类型的卸载。 2.堆 作用：存放对象实例，几乎所有的对象，数组。 GC：最容易OOM。-Xms -Xmx 引用计数法：存在两个对象相互引用的问题。 可达性分析算法：（主流）GC Root可以是：虚拟机栈，方法中静态属性引用的对象，方法区中常量......
Java高级看这篇就足够了(高级知识汇总)
热门推荐
SYJ的博客
12-17 1万+
第 1 章封装性 1.1封装性介绍 编程语言中，封装有2层意思： 1.将重复的代码提取到一个公共的方法中，从而提升代码的复用性、可维护性 2.如果成员变量未加封装密封，可以在类的外部被肆无忌惮的修改 封装性是指，将对象的属性和行为进行密封，保护数据并隐蔽具体的细节，在类的外部不可直接访问，要想访问需要通过严格的接口控制。 封装性的目的：采用封装的思想保证了类内部数据结构的完整性，应用该类的用户不能轻易直接操纵该数据结构， 封装的原则就是要求在类的外部，不能随意存取对象的内部数据(成员属性和成员方法).从而
Java高级学习
xiaoming_Super的博客
04-25 148
2. 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。此外，BigInteger、BigDecimal 用于高精度的运算，BigInteger 支持任意精度的整数，也是引用类型，但它们没有相对应的基本类型。
Java高级部分学习
Flowermoon的博客
11-28 282
Java高级部分学习
java学习高级篇（一）
qq_42999126的博客
03-03 290
Java学习IO流部分File类的使用IO流原理及流的分类IO原理流的分类节点流和处理流缓冲流转换流标准输入输出流 IO流部分 File类的使用 File 类的使用 1、File类的一个对象，代表一个文件或者一个文件目录 2、File类声明在java.io包下面 File类的构造方法 File类路径问题 相对路径 相对于本module 绝对路径 在磁盘上的路径 File类的常用方法 public String getAbsolutePath()：获取绝对路径 File file1 = new File(
Java基础及高级学习笔记.zip
最新发布
09-26
本资料包“Java基础及高级学习笔记.zip”涵盖了Java的基础知识、进阶概念以及与面试相关的知识点，旨在帮助学习者从入门到精通，提升专业技能。 首先，"java基础.docx"文件详细讲解了Java的基础内容。这部分通常...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java基础尚硅谷宋红康学习笔记
05-29
【Java基础】 Java是一种广泛使用的面向对象...这些是Java基础知识和高级技术的主要组成部分，掌握它们能够帮助开发者构建稳定、高效、可维护的Java应用程序。通过深入学习和实践，你可以不断提升自己的Java编程能力。
Java基础到高级学习笔记.rar
03-06
这份"Java基础到高级学习笔记.rar"包含了从基础到高级的全面Java学习资源，适合初学者和进阶者深入理解Java的核心概念和技术。 首先，我们看到的《Java程序设计基础》课程笔记01（含第1-2章）.docx，这部分内容可能...
java从入门到高级的学习全攻略
03-22
JAVA运行环境的搭建、学习攻略、学习参考书目的推荐等系统介绍JAVA开发学习的指南。
java基础学习笔记之反射
09-02
Java反射是Java编程语言的一个重要特性，它允许程序在运行时检查类的信息并动态地创建和操作类的对象。反射提供了一种方式，使得程序能够访问和修改私有成员（包括字段和方法），甚至调用私有构造器。这种能力使得...
java知识点3
weixin_34409703的博客
04-03 79
高级篇 新技术 Java 8 lambda表达式、Stream API、 Java 9 Jigsaw、Jshell、Reactive Streams Java 10 局部变量类型推断、G1的并行Full GC、ThreadLocal握手机制 Spring 5 响应式编程 Spring Boot 2.0 性能优化 使用单例、使用Future模式、使用线程池、选择就绪、减少上下文切换...
Java高级特性学习（超详细）一（集合）
jojo_oulaoula的博客
06-16 345
缘由：由于数组在创建的时候会默认定义数组的长度，而数组的长度是不变的，所以导致数组的赋值及创建会有内存浪费的现象，于是集合作为可以更改长度的数组，可以解决内存浪费的现象。
java高级学习总结
qq_55691662的博客
08-05 420
java高级学习了2周，相比于前面2阶段的学习。java高级学习了很多知识，各种各样。原本在大二的时候java只是一门选修课，学习的就是java基础和面向对象。java高级基本没啥基础，对于我来说这些都是新知识，感觉需要掌握起来还是学要时间的。像在接触集合的时候，学习到了四种集合，每个集合各有各的特点，有属于自己的方法。想掌握还需要多多练习。在学习文件操作的时候，对于文件字节输入流和字节输出流，就出现了很多错误，经常把方向记错了。......
史上最全面的Java高级学习体系（没有之一）
happylzs2008的专栏
08-15 2441
前言： 前几天，有一位同学问我说：“George老师，我现在出来工作4年左右了，可现在我总觉得我在工作中有好多的技术需要学习，不然跟不上公司发展的脚步，自己也想着能够提升些薪资，所以就在网上也找了相关的视屏与资料，也买了很多的书籍来自学，可总是学不会，也不能够快速理解里面的很多内容，现在也白白浪费了好几个月的时间。实在是没办法了，所以现在才找到您，想请你帮帮我”。根据这位同学的言辞，我也只能是表
JavaSE高级篇学习笔记
bryn_li的博客
09-21 1078
基本数据类型的封装类 1.byte Byte char Character short Short int Integer long Long folat Float double Double boolean Boolean 2.自动装箱与拆箱 装箱：把基本数据类型转化为封装类型
java学习入门到精通
weixin_34254823的博客
07-23 77
工具篇JDK (Java Development Kit) JDK是整个Java的核心，包括了Java运行环境（Java Runtime Envirnment），一堆Java工具和Java基础的类库(rt.jar)。不论什么Java应用服务器实质都是内置了某个版本的JDK。因此掌握 JDK是学好Java的第一步。最主流的JDK是Sun公司发布的JDK，除了Sun之外，还有很多公司和组织都开发了自...
java高级工程师的几点要求
cenfei78325747的专栏
02-16 721
1.技术广度方面 至少要精通多门开源技术吧，研究过struts\spring等的源码。 2.项目经验方面 从头到尾跟过几个大项目，头是指需求阶段，包括需求调研。 尾是指上线交付之后，包括维护阶段。 3.架构经验方面 有过分布式系统的架构和开发经验。对于跨系统的结构优化，数据存储的性能指标等有丰富经验。什么缓存啊、数据库的垂直切分什么的，业务的抽象和水平拆分啊，这些应该都轻车熟路吧。 4.行业
Java编程基础与学习笔记
"这是一份全面的Java学习笔记，涵盖了从环境配置到高级特性的多个方面。笔记作者深入探讨了Java的基础知识，包括类、对象、变量的内存存储，以及容器、异常处理和多线程等内容。此外，笔记还强调了Java语言的面向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值