投稿
  1. 首页
  2. java

Java入门与实践

code • 2022-5-13 • java • 阅读 34

Java入门与实践,第1张

Java基础

Java基础
  • Java基础
    • Java帝国的诞生
    • Java发展
    • JAVA特性和优势
    • JAVA三大版本
    • JDK JRE JVM
    • Hello Wolrd
    • Java环境运行机制
  • Java基本语法
    • 创建 `IntelliJ IDEA` 项目
    • 编写代码，运行环境
    • 注释
      • 单行注释
      • 多行注释 (快捷键：`选中+Ctrl+/` 注释取消：`选中+Ctrl+/`)
      • 文档注释 （快捷键：`/**+Enter`）
    • 标识符与关键字
      • 标识符注意点
    • 数据类型
      • 强类型语言
      • 弱类型语言
      • Java的数据类型，分为两大类
    • 字节
    • 拓展
    • 类型转换
    • 变量
      • 变量作用域
    • 常量
    • 变量的命名规范
    • 运算符
      • 运算符优先级
    • 包机制 (文件夹)
    • JavaDoc
      • 生成自己的API文档
    • 来源：狂神说

Java帝国的诞生

  • 1972年c诞生

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

  • 1982年c++诞生

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

  • 急需建立一个新语言

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

  • Java面世——原名oak 现在叫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虚拟机

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基本语法 创建 IntelliJ IDEA 项目

打开 IntelliJ IDEA 选择 New Project：

命名项目名，创建项目文件：（我这里创建的是一个空项目，之后加模块！）

等待加载完成：


创建模块：（这里再创建模块，用于区分各个不同的功能）

选择Java模块

命名模块：

配置Java环境:

编写代码，运行环境

创建class文件：

我这里创建的是：Hello.java

文件多的时候可以创建包：

写包名：

选中几个文件进行移动时：


编写代码：

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

运行代码：

结果：
在设置里允许滑动滚轮调整字体大小：
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：


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

注释

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

单行注释 
// 这里是单行注释
多行注释 (快捷键：选中+Ctrl+/ 注释取消：选中+Ctrl+/) 
/* 
多行注释，可以注释一段文字
    多行注释
    多行注释
*/
文档注释 （快捷键：/**+Enter） 
/**
*@Description 这里是描述
*@Author 这里表明作者
*/

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


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）
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;
  
}
字节

  • 位（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

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

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

// 定义包：写在所有代码的最前面
// 查看包：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官方文档

Jdk8官方文档

  • 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代码：

代码运行后会生成很多文件：关注index.html

文档内容：

来源：狂神说

狂神说

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/868958.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-05-13
下一篇 2022-05-13

发表评论

登录后才能评论

评论列表（0条）

保存