Java入门与实践

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)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-05-13
下一篇 2022-05-13

发表评论

登录后才能评论

评论列表(0条)

保存