Java入门与实践(初入职场，工作复习)——Java基础

已于 2022-05-03 17:10:00 修改
阅读量979 收藏 1
点赞数 1
分类专栏： Java开发 文章标签： java 开发语言 intellij idea 后端
于 2022-05-03 17:06:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45048331/article/details/124557329
版权

Java基础

Java基础

Java帝国的诞生

  • 1972年c诞生

    • 贴近硬件，运行极快，效率极高
    • 操作系统，编译器，数据库，网络系统等
    • 指针和内存管理 指针：没有给越界检查，轻易犯错。内存：自己分配空间，自己释放。
    • 时间浪费掉在指针和内存分配上！

  • 1982年c++诞生

    • 面向对象
    • 兼容c
    • 图形领域，游戏等

  • 急需建立一个新语言

    • 语法优点像c
    • 没有指针
    • 没有内存管理
    • 真正的可移植性 # java虚拟机jvm
    • 面向对象
    • 类型安全
    • 高质量类库
    • …

  • Java面世——原名oak 现在叫Java
    java

  • 1995年的网页简单而粗糙 缺乏互动性

  • 图形界面的程（Applet）

  • Bill Gates 这是迄今为止设计的最好的语言！

  • Java 2 标准版（J2SE）去占领桌面

  • Java 2 移动版（J2ME）去占领手机

  • Java 2 企业端（J2EE）去占领服务器

  • 大量的巨头加入

Java发展

  • 很多商业巨头纷纷加入：
    • 三高： 高可用 高性能 高并发
    • 他们基于Java开发了巨多的平台，系统，工具
    • 构建工具：Ant Maven Jekins
    • 应用服务器：Tomcat，Jetty，Jboss，Websphere，weblogic
    • Web开发：Struts，Spring，Hibernate，myBatis
    • 开发工具：Eclipse，Netbean，intellij idea，Jbuilder
    • 2006 Hadoop（大数据领域）
    • 2008 Android （手机端）

JAVA特性和优势

  • 简单性（简单易学，免费使用）
  • 面向对象
  • 可以移植性 ——Write Once, Run Anywher！
  • 高性能
  • 分布式
  • 动态性 反射机制，
  • 多线程
  • 安全性
  • 健壮性

JAVA三大版本

Write Once, Run Anywhere——JVM（Java虚拟机，可以跨平台！）
JavaSE（Java Platform Standard Edition）：标准版（桌面程序，控制台开发…）
JavaME（Java Platform Micro Edition）：嵌入式开发（手机，小家电）现在基本死掉了
JavaEE（Java Platform Enterprise Edition）：企业版，企业级开发，（web端，服务器开发…）

JDK JRE JVM

JDK: Java Development Kit ｜Java 开发者工具：包括所有东西JRE、JVM等一些开发工具
JRE：Java Runtime Environment ｜Java 运行环境：包含Java虚拟机(JVM)、Applet
JVM：JAVA Virtual Machine | Java虚拟机
java

Hello Wolrd

  1. 随便新建一个文件夹，用来存放代码：

  2. 新建一个Java文件 ，文件后缀名为.java
    例：Hello.java

【注意点】：系统可能没有显示文件后缀名，我们需要手动打开

  1. 编写程序
public class Hello{  // 定义一个类,类名是Hello要和文件名一样，我这里文件名是Hello.java
	public static void main(String[] args){  // 核心方法：主方法,程序通过main方法执行
 		System.out.println("Hello,World!");    // 输出 Hello World！
}
}
  1. 编译，命令行进入java文件目录下：javac java文件 ，会生成一个class文件（字节码文件）
  2. 运行class文件：java class文件名（不要加后缀名）
javac Hello.java
java Hello

可能遇到的情况：

  1. 每个单词的大小写不能出现问题 Java大小写敏感
  2. 尽量使用英文
  3. 文件名和类名，必须保证一致
  4. 符号使用了中文。需要是英文

Java环境运行机制

  • 编译型 (Compile)
    • 有一个负责编译的程序（编译器），把整个程序编译成机器语言让计算机使用
    • 速度很快，因此多用于操作系统
    • 必要时需要重新编译
    • 例如：操作系统 c语言
  • 解释型
    • 执行一句，解释一句。
    • 效率不高，速度不要求
    • 例如：网页，服务器脚本对速度要求不高 ，如：js
    • 现在随着硬件技术的提高，解释型的效率也提高了，和编译型速度界限变得模糊了
  • Java程序运行机制——先编译，后解释（.class文件才真正的去执行）
    java

Java基本语法

创建 IntelliJ IDEA 项目

打开 IntelliJ IDEA 选择 New Project：
java

命名项目名，创建项目文件：（我这里创建的是一个空项目，之后加模块！）
java
等待加载完成：
java
java
创建模块：（这里再创建模块，用于区分各个不同的功能）
java
选择Java模块
java
命名模块：
java
配置Java环境:
javajava

编写代码，运行环境

创建class文件：
java
我这里创建的是：Hello.java
java
文件多的时候可以创建包：
java
写包名：
java

选中几个文件进行移动时：
java
java
编写代码：

public class Hello {
    public static void main(String[] args){
        System.out.println("Hello，World！");
    }
}

运行代码：
java
结果：java
在设置里允许滑动滚轮调整字体大小：
Windows系统：File -> Setting -> Editor -> General -> Change font size with Command+Mouse Wheel in：
macOS: IntelliJ IDEA -> Preferences...-> Editor -> General -> Change font size with Command+Mouse Wheel in：

java
还可以配置字体颜色：（以注释举例）
java

注释

平时我们编写代码，代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要注释了。
注释并不会被执行，是给我们写代码的人看的
书写注释是一个非常好的习惯
平时写代码一定要注意规范

单行注释

// 这里是单行注释

多行注释 (快捷键：选中+Ctrl+/ 注释取消：选中+Ctrl+/)

/* 
多行注释，可以注释一段文字
    多行注释
    多行注释
*/

文档注释 （快捷键：/**+Enter）

/**
*@Description 这里是描述
*@Author 这里表明作者
*/

//有趣的代码注释
/***
 *                    _ooOoo_
 *                   o8888888o
 *                   88" . "88
 *                   (| -_- |)
 *                    O\ = /O
 *                ____/`---'\____
 *              .   ' \\| |// `.
 *               / \\||| : |||// \
 *             / _||||| -:- |||||- \
 *               | | \\\ - /// | |
 *             | \_| ''\---/'' | |
 *              \ .-\__ `-` ___/-. /
 *           ___`. .' /--.--\ `. . __
 *        ."" '< `.___\_<|>_/___.' >'"".
 *       | | : `- \`.;`\ _ /`;.`/ - ` : | |
 *         \ \ `-. \_ __\ /__ _/ .-` / /
 * ======`-.____`-.___\_____/___.-`____.-'======
 *                    `=---='
 *
 * .............................................
 *          佛祖保佑             永无BUG
 */

标识符与关键字

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

标识符注意点

  • 所有的标识符，都应该以字母(A-Z或者a-z) 美元符($)或者下划线()开始
  • 首字母之后 可以可以是字母，(A-Z 或者 a-z)，美元符（$)、下划线（_）或数字的任何字符组合
  • 不能使用关键字作为变量名或方法名。
  • 标识符是大小写敏感的
  • 合法标识符举例：age、$salary、_value_、__1_value
  • 非法标识符举例：123abc、-salary、#abc
  • 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low。

数据类型

强类型语言

  • 要求变量的使用要 严格符合规定，所有变量都必须 先定义 后才能使用。 因此安全性高，但是速度慢。

弱类型语言

  • 要求变量的使用符合规定即可，所有变量都必须先定义后才能使用。 因此安全性高，但是速度慢。
public static void main(){
		String a = "hello";  //必须按数字类型定义
		int num = 10;
		System.out.println(a);
		System.out.println(num);
}

Java的数据类型，分为两大类

  • 基本类型：（primitive type）
  • 引用类型：（refreence type）
基本数据类型:PrimitiveType
数值类型
整数类型
byte占1个字节范围:-128到127
short占2个字节范围:-32768到32767
int占4个字节范围:-2147483648到2147483647
long占8个字节范围:-9223372036854775808到9223372036854775807
浮点类型:小数
float占4个字节
double占8个字节 常用
字符类型
char占2个字节
boolean类型:占1位其值只有true和false两个 
public class Demo2{
  //八大基本数据类型  快捷键查看类：command或ctrl + 点击
  //整数
	int num1 = 10; //最常用
	byte num2 = 20;
	short num3 = 30;
	long num4 = 30L; //long类型要在最后加L
	
	//浮点数 （小数）
	float num5 = 50.1F; //float类型要在数字最后加F
	double num6 = 3.1415926;
  
  //字符类型
  char name = '中';
  //字符串，String不是关键字，是类
  //String name = "hello"
    
  //boolean 布尔值：是,非
  boolean flag = true;
  boolean flag2 = false;
  
}
引用数据类型:ReferenceType
类
接口
数组

字节

  • 位（bit）：是计算机内部数据储存的最小单位 ，11001100是一个 八位 二进制数

  • 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示，

  • 1B（byte，字节） = 8bit（位）

  • 字符：是指计算机中使用的字母，数字，字和符号（例：'a'，'A'，'中'，'国'）

  • 1bit 表示1位

  • 1byte表示一个字节 1B = 8b

  • 1024B = 1KB

  • 1024KB = 1MB

  • 1024MB = 1GB

  • 1024GB = 1TB

拓展

public class Demo2 {
    public static void main(String[] args){
        //数据拓展 进制 二进制：0b开头  十进制  八进制：0开头  十六进制:0x开头
        int i = 10;
        int i2 = 010;  // 八进制：0开头   逢8进1
        int i3 = 0x10; // 十六进制:0x开头  逢16进1   0~9 A~F

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("===================================");

        //==========================================
        //浮点数拓展  央行业务怎么表示
        float f = 0.1f;    //0.1
        double d = 1.0/10; //0.1
        System.out.println(f);
        System.out.println(d);
        System.out.println(f==d);

        float f1 = 212121212F;
        float f2 = f1 + 1;
        System.out.println(f1 == f2 );  //结果为：true 相同

        //原因：浮点数 float：是有限离散的，有舍入误差，其结果是个大约数，接近但是不等于
        //最好完全避免使用浮点数比较大小！
        //最好完全避免使用浮点数比较大小！
        //最好完全避免使用浮点数比较大小！
        //使用BigDecimal数学工具类进行银行业务

        System.out.println("===================================");
        //======================================
        //字符拓展
        char c1 = 'a';
        char c2 = '中';

        System.out.println(c1);
        System.out.println((int)c1); //强制转换
        System.out.println(c2);
        System.out.println((int)c2); //强制转换

        //所有的字符本质上还是数字
        //编码 Unicode ASCII码：a = 97,A = 65,占2字节 最多表示0～65536个字符   最早的Excel表格只有2的16次方，65536
        char c3 = '\u0061'; //定义一个Unicode编码
        System.out.println(c3); //a
        System.out.println("===================================");

        //转义字符
        // \t 制表符 tab空格
        // \n 换行符
        //......
        System.out.println("Hello\nWorld");

        System.out.println("===================================");
        
        //对象 从内存分析
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa == sb); //内存存储原因：false
        
        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc == sd);//内存存储：true

        System.out.println("===================================");
        
        //布尔值扩展
        boolean flag = true;
        //代码要精简易读 Less is More!
        if(flag == true){};//新手
        if (flag){};//老手
        
    }
}

类型转换

  • 由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。
低 -----------------------------------------> 高 （小数优先级大于整数）
byte,short,char -> int -> long -> float -> double
  • 运算中，不同类型的数据转化为同一类型，然后进行运算。
    • 强制类型转换
    • 自动类型转换
public class Demo3 {
    public static void main(String[] args){
        int i = 128;  
        //强制转换   (类型)变量名   高 -> 低
        byte b = (byte)i; //内存溢出    
        System.out.println(i); // 128
        System.out.println(b); //-128 
        
        //自动转换   低 -> 高
        double d = i
    }
}

byte范围是：-128～127
java

public class Demo3 {
    public static void main(String[] args){
        int i = 128;
        //强制转换 (类型)变量名 高 -> 低
        byte b = (byte)i;  //内存溢出
        System.out.println(i);//128
        System.out.println(b);//-128

        //自动转换   低 -> 高
        double d = i;
        System.out.println(i);//128
        System.out.println(d);//128.0

        System.out.println("=========================");
        //精度问题
        System.out.println("23.7强制转换int类型："+(int)23.7);//23
        System.out.println("-45.98f强制转换int类型："+(int)-45.89f);//-45

        System.out.println("=========================");
        char c = 'a';
        int e = c+1; //低到高，自动转换
        System.out.println(e); //98
        System.out.println((char)e);// 转换回char类型，高到低，强制转换 //b

        /*
        注意点：
        1. 不能对boolean值进行转换
        2. 不能把类型转换为不相干的类型
        3. 在把高容量转换为低容量的时候，强制转换，反之自动转换
        4. 转换的时候可能存在内存溢出或者精度问题。
         */

        System.out.println("=========================");
        //操作比较大的数的时候，注意溢出问题
        //JDK7 新特性，数字之间可以使用下划线分割
        int money = 10_0000_0000; // 不会输出下划线 _
        System.out.println(money);//1000000000

        int years = 20;
        int total = money*years; //计算的时候溢出了
        System.out.println(total); //-1474836480

        double total2 = money*years; //默认是int类型，转换之前已经出现问题了，因此就是把结果转换成long
        System.out.println(total2);
        long total3 = money*((long)years);//先把一个数转换成long
        System.out.println(total3);
        
        //因为long L 和 l 都可以 但是l容易看成1，所以建议都使用L
    }
}

变量

  • 变量是什么：就是可以变化的量！（代表一个空间，空间里面存储的值是可以变化的。）
  • Java是一种强类型语言，每个变量都必须声明其类型。
  • Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
type varName  [=value] [{,varName[=value]}];
   // 数据类型 变量名 = 值; 
   //可以使用逗号隔开来声明多个同类型变量(不建议用)。
  • 注意事项：
    • 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
    • 变量名必须是合法的标识符。
    • 变量声明是一条完整的语句，因此每一个声明都必须以分号结束。
public class Demo4 {
    
    public static void main(String[] args){
         //int  a,b,c; //不建议
        //程序的 可读性
         int a = 1;
         int b = 2;
         int c = 3;
         String name = "name";
         char x = 'X';
         double p1 = 3.14;
         
    }
}

变量作用域

  • 类变量
  • 实例变量
  • 局部变量
public class Demo5 {

    // 常量
    //public private final static 修饰符 不存在先后顺序
    static final double PI = 3.14;
    final static double PI2 = 3.14;

    //属性：变量

    // 类变量 static  与类一起出现，一起消失！
    static double salary = 2500;

    //实例变量：从属于对象，在方法外面定义
    //如果不自行初始化，这个类型的默认值：0，0.0, null(u0000)
    // 布尔值 boolean默认：false
    // 除了基本类型，其余的默认值都是null
    String str ; //实例变量
    int age;

    static int allClicks = 0;  // 类变量  static 静态的

    //main方法：主程序方法
    public static void main(String[] args){

        //常量
        System.out.println(PI);
        System.out.println(PI2);

        //局部变量 是在方法里：{}里 ：必须声明和初始化值
        int i = 10;

        //使用实例变量：变量名字 == new Demo5();
        //变量类型 Demo5
        Demo5 demo5 = new Demo5(); //建立对象
        System.out.println(demo5.age); //没有默认初始值，初始值为0
        System.out.println(demo5.str); //没有默认初始值，默认值 null

        //类变量 static
        System.out.println(salary);//可以直接输出

    }

    //其他方法
    public void method(){
        int i = 0; //局部变量
    }

}

常量

  • 常量（Constant）:初始化（initialize）后不能再改变值！不会变动的值。
  • 所有常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
  • 常量名一般使用大写字符！

变量的命名规范

  • 所有变量：方法、类名：见名知意
  • 类成员变量：首字母小写和驼峰原则：monthSalary (除了第一个单词，后面的单词首字母大写 lastName)
  • 局部变量：首字母小写和驼峰原则
  • 常量：大写字母和下划线：MAX_VALUE
  • 类名：首字母大写和驼峰原则：Man，GoodMan
  • 方法名：首字母小写和驼峰原则：run()，runRun()

运算符

  • Java 语言支持如下运算符：
    • 算术运算符：+、-、*、/、%（取余）、++、--
    • 赋值运算符：=
    • 关系运算符：>、<、>=、<=、==（等于）、!=（不等于）、instanceof
    • 逻辑运算符：&&（与）、||（或）、！（非）
    • 位运算符：&、｜、^、~、>>、<<、>>>（了解即可）
    • 条件运算符：？、：
    • 扩展赋值运算符：+=、-=、*=、/=
package operator;

/**
 * 计算
 */
public class Demo1 {
    public static void main(String[] args){
        //二元运算符
        // Ctrl + D  复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);// 0.5 不是int类型 四舍五入 需要强转 a/(double)b

        System.out.println("=====================");
        long l1 = 1212121212;
        int i = 123;
        short s = 10;
        byte dd = 8;

        System.out.println(l1+i+s+dd); //long 只要存在long类型，结果也为long类型
        System.out.println(i+s+dd); //int 没有long类型，结果都为int
        System.out.println(s+dd);// int
        System.out.println((double)s+dd);//double 类型  只要存在double类型，结果也为double类型


        System.out.println("=====================");
        //关系运算符的结果：布尔值 正确 错误
        //多和if 一起用
        int a1 = 10;
        int a2 = 20;

        System.out.println(a>b);//false
        System.out.println(a<b);//true
        System.out.println(a==b);//false
        System.out.println(a!=b);//true

        System.out.println("=====================");

        //取余 模运算
        int a3 = 21;

        System.out.println(a3%a1); // c/a =  21/10 = 2.......1

        System.out.println("=====================");
        //++ 自增 -- 自减 一元运算符

        int f = 3;
        int g = f++; // 执行完这个代码后，先给g赋值，再自增
        // f = f + 1  执行完
        System.out.println("f="+f);// 4
        System.out.println("g="+g);// 3 先给g赋值，再自增
        System.out.println("f="+f);// 4

        System.out.println("+++++++++++++++");
        f = 3;
        int h = ++f; // 执行完这个代码前，先再自增，再给h赋值
        // f = f + 1  执行完
        System.out.println("f="+f);// 4
        System.out.println("h="+h);// 4 先再自增，再给h赋值
        System.out.println("f="+f);// 4

        System.out.println(f);// 4
        System.out.println(g);// 3
        System.out.println(h);// 4

        System.out.println("=====================");
        // 幂运算  使用工具类来操作
        double pow = Math.pow(2,3);// 2^3 = 2*2*2 = 8
        System.out.println(pow);
    }
}

package operator;

/**
 * 逻辑运算
 */
public class Demo2 {
    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)));//逻辑非运算：如果是真即为假，如果为假即为真

        //短路运算
        int c = 5;
        boolean d = (c < 4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);// 5 因为(c < 4)&&(c++<4)中(c < 4)已经为false，因此不会再计算(c++<4) c依旧为5

        //位运算
        /*
        与运算：0与0 = 0   0与1，1与0 = 0  1与1 = 1
        或运算：0或0 = 0   0或1，1或0 = 1  1或1 = 1
        异或运算：相同即为0 不同即为1
        取反：0取1 1取0 取反

        A = 0011 1100
        B = 0000 1101
       ----------------------
        A&B  0000 1100
        A|B  0011 1101
        A^B  0011 0001
        ~B   1111 0010
         */

        /*
        //面试题：
        2*8 如何计算最块?
        2*8 = 16 2*2*2*2 位运算
        << 左移
        >> 右移
         */
        System.out.println("====================");
        /*
        0000 0000  0
        0000 0001  1
        0000 0010  2
        0000 0011  3
        0000 0100  4
        0000 1000  8
        0001 0000  16
        位运算效率极高
        <<  *2
        >>  /2
        */
        System.out.println(2<<3);

        System.out.println("====================");
        //
        int x = 10;
        int y = 20;

        x+= y; //x = x+y
        System.out.println(x);

        x = 10;
        y = 20;
        x-= y; //x = x-y
        System.out.println(x);

        System.out.println("====================");
        x = 10;
        y = 20;
        //字符串链接符  +
        System.out.println("——"+ x + y);// ——1020 只要+两侧有一侧是String类型，
        System.out.println(x + y +"——");// 30——  如果先+是数，则先计算后String拼接

        System.out.println("====================");
        //三元运算符  ？ ：
        // x ? y : z
        //如果x==true，则结果为y，否则结果为z

        int score = 80;
        String type1 = score < 60 ? "不及格": "及格";
        System.out.println(type1);//及格

        score = 50;
        String type2 = score < 60 ? "不及格": "及格";
        System.out.println(type2);//不及格
    }

}

运算符优先级

java

包机制 (文件夹)

  • 为了更好的组织类，Java提供了包机制，用于区别类名的命名空间。
  • 包语句的语法格式为：
    package pkg1[.pkg2[.pkg3...]];
  • 一般利用公司域名倒置作为包名 ：com.test.blog.www
  • 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用import语句可完成此功能
    import package1[.package2...].(classname|*);

改变一下以上项目的存储方式：
java

// 定义包：写在所有代码的最前面
// 查看包：command/Ctrl + 点击 
package com.learn.base;
package com.learn.operator;

//导入包
//自动生成包，快捷键macOS：option+shift+Enter  Windows: Alt+Enter
import com.learn.base.Demo1 //必须在package...下面
import com.learn.* //.*通配符，导入包下所有的类

JavaDoc

Java官方文档java

Jdk8官方文档
java

  • Javadoc命令是用来生成自己的API文档的
  • 参数信息：
    • @author 作者名
    • @version 版本号
    • @since 指明需要最早使用的jdk版本
    • @param 参数名
    • @return 返回值情况
    • @throws 一场抛出情况

生成自己的API文档

先写好自己的注释

package com.learn.base;

/**
 * @author name 
 * @version 1.0    
 * @since 1.8   
 */
public class doc {
    String name;
    
    /**
     * 
     * @param name        //参数
     * @return            //返回值
     * @throws Exception  //异常
     */
    public String test(String name) throws Exception{
        return name;
    }
     //通过命令行生成文档： javadoc 参数 java文件
}

自动生成文档：
可以在要生成文档的的文件夹下打开命令行：(在当前doc文件下)

# encoding 编码  chartset 字符集编码 可显示中文
javadoc -encoding UTF-8 -charset UTF-8 doc.java

cmd代码：
java
代码运行后会生成很多文件：关注index.html
java
文档内容：
java

来源：狂神说

狂神说

.G( );
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaG-开源
07-08
用 Java 编写的用于 2D 和 3D 游戏的游戏开发框架。 被用作 1996 年经典 Toxic Bunny 从 C++ 移植的基础。
30个Java入门技巧和最佳实践
最佳 Java 编程
05-29 680
Java是最流行的编程语言之一-无论是Win应用程序，Web应用程序，移动，网络，消费电子产品，机顶盒设备，Java随处可见。 在Java上运行的设备超过30亿。 据甲骨文称 ，正在使用50亿张Java卡。 超过900万的开发人员选择用Java编写代码 ，它在开发人员中非常流行，同时也是最流行的开发平台。 对于即将到来的Java开发人员，此博客提供了一段时间内已学习的最佳实践的集...
Java0基础入门实践宝典（一）
qq_41698832的博客
04-29 910
第一篇:初识Java ————工欲善其事必先利其器 Java是一种跨平台的，面向对象的程序设计语言。本篇先介绍Java语言的不同版本及相关特性及学好Java语言的方法等，然后重点对Java环境的搭建。Ecplipse，IDEA的下载及使用尽兴详细的讲解。最后了解基本的Java调试程序步骤。 本篇任务： 了解Java语言及其版本 熟练掌握Java环境的搭建 掌握如何下载并配置Eclipse 熟悉第一个Java程序 掌握Eclipse的使用（IDEA后期介绍） 掌握程序调试 .
java中 g.drawImage()方法如何使用
热门推荐
evilcry2012的专栏
02-09 2万+
java中 g.drawImage()方法如何使用 2013-04-08 09:04contact999 | 分类：JAVA相关 | 浏览1921次 File file=new File("d:\\img\\5.jpg"); BufferedImage bi=ImageIO.read(file); Graphics g=bi.getGraphics(); g.drawImage(i
java中g开头命名的_java标识符和命名规则 java语言基础之标识符和命名规则详解...
weixin_42471237的博客
03-09 180
想了解java语言基础之标识符和命名规则详解的相关内容吗，落地而死的大鸟在本文为您仔细讲解java标识符和命名规则的相关知识和一些Code实例，欢迎阅读和指正，我们先划重点：java标识符命名规则,java标识符有哪些,java类的命名规则，下面大家一起来学习吧。标识符Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符技巧：凡是自己可以起名字的地方都叫标识符定义合法标识符规则：由2...
java基础——入门篇
07-14
因为在jdk下bin文件夹中有很多我们在开发中要使用的工具如javaexejavacexejarex等那么我们在使用时想要在电脑的任意位置下使用这些java开发工具那么我们就需有把这些工具所在的路径配置到系统的环境变量中当我们使用...
java基础篇——java的起源与演变
07-14
Java 的跨平台原理: Java 源代码---编译--->java 字节码(可跨平台) ---运行--->JVM(java 虚拟机)→Windows,Linux 等平台。JVM 屏蔽了底层运行平台的差别,实现了“以此编译,随处运行”。 垃圾回收器: 不...
《分布式Java应用基础与实践》pdf电子版
09-17
《分布式Java应用基础与实践》pdf电子版，
Java期末复习——枚举与反射机制
08-07
Java——枚举： enum关键字、Enum类 类集对枚举的支持——EnumMap类与EnumSet类 枚举类实现接口、在枚举类中定义抽象方法 Java反射机制： Class类、Class类的使用 反射的应用：取得类的结构
Java入门1·2·3——一个老鸟的Java学习心得
07-22
资源名称：Java入门1·2·3——一个老鸟的Java学习心得内容简介：本书是一本与众不同的Java入门好书。作者以独特的视角，向Java初学者讲述了如何才能真正理解和掌握Java语言。本书充分考虑了初学Java语言的种种困难...
JAVA 学习第一篇（基础实践）
FLY的专栏
07-21 276
第一个Java 运行 vim Helloworld.java javac Helloworld.java //编译java语言 java Helloworld //运行Java语言 基础知识： 1.java语言不使用指针，而是引用也就是公用一块内存地址。并且有自己的内存管理机制，后续在详细学习； 2.Java只支持类之间的单继承，并支持接口之间的多集成（不太理解）。 3.j...
java从入门到实践
巩永钦的博客
03-14 836
Java的入门到实践如何学习java基础JavaEE入门学习项目问题书籍推荐Java学习目标（java具体要学什么）java语言基本使用能力多线程并发数据库javaEElinux系统设计算法分布式大佬项目分享 如何学习java基础 建议初学者看视频学习，不推荐看书。入门视频选择非常重要，最好是通俗易懂、深入浅出的教学视频。如果入门视频选的不好，不知所云，容易产生厌倦心理：“从入门到放弃”。关于ja...
java初学者实践教程－网络程序
as12345ss的博客
07-06 71
Java在网络编程这个地方做的很好，java的主要目的也是为了网络而生的，它能方便的访问网络上的资源。我们这节课来介绍网络通讯的两种机制：URL通信机制，Socket通信机制。 URL表示了Internet上一个资源的引用或地址。Java网络应用程序也是使用URL来定位要访问的Internet的资源。在jdk里面java.net.URL也是一个类，它来封装URL的一些细节。目前大家可以把URL理解为网址，default.aspx 这就是个URL.http是协议名（超文本传输协议）用“://”隔开 ww
java入职实习：基础学习:http请求方式(put,post,delete,get),equals==,字符串常见方法
weixin_43930851的博客
06-06 513
入职记录
Java入门实战篇1
qq_41534115的博客
07-09 1558
Java入门实战总结 1. 双色球 红球：随机生成6个1-32的不重复整数 蓝球：随机生成一个1-16的整数  /** 1.双色球  */  public class Test1{  //方法入口  public static void main(String []args){    int []a=new int[6];//初始化数组  for(int i=0;i&lt;6...
玩转MySQL：60分钟快速掌握RabbitMQ，BAT大厂面试总结
m0_56301848的博客
04-21 244
前言 作为一个典型的分布式项目，Kubernetes 的部署一直以来都是挡在初学者前面的一只“拦路虎”。尤其是在 Kubernetes 项目发布初期，它的部署完全要依靠一堆由社区维护的脚本。 其实，Kubernetes 作为一个 Golang 项目，已经免去了很多类似于 Python 项目要安装语言级别依赖的麻烦。但是，除了将各个组件编译成二进制文件外，用户还要负责为这些二进制文件编写对应的配置文件、配置自启动脚本，以及为 kube-apiserver 配置授权文件等等诸多运维工作。 这几年，在跟朋友探讨
Java新手小白入门篇 Java基础（一）
weixin_46030002的博客
08-02 2466
Java基础（第一天） Java运行过程（编译，运行），名词解释（JDK，JRE，JVM），IDEA简单使用
头歌实践教学平台java入门 循环结构基础
最新发布
09-21
头歌实践教学平台的Java入门课程中，循环结构基础包括了嵌套循环和图的相关知识。在第2关的嵌套循环实践中，通过使用嵌套的for循环来打印出一个正三角形和一个倒三角形。正三角形的打印使用了两个for循环，外层循环控制行数，内层循环控制每行打印的星号数量。倒三角形的打印也是使用两个for循环，外层循环控制行数，内层循环控制每行打印的星号数量。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值