Java入门 —— 打开Java世界的大门

目录

一. 了解Java

二.Java入门

三.变量

---

一. 了解Java

1.什么是程序

        ——计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合

2.Java是如何诞生的

        ——1990年，sun公司启动了绿色计划，1992年sun公司创建了oak语言，后改名为Java，1994年，gosling参加硅谷大会演示Java功能，震惊了世界，1995年，sun公式正式发布了Java的第一个版本，2009年，甲骨文公司收购了sun公司，2011年，甲骨文公司发布了Java7……

3.Java技术体系平台

        1）JavaSE(Java Standard Edition)标准版

                ——支持面向桌面级的应用（如Windows下的应用程序）的Java平台，提供完整的Java核心API

        2）JavaEE(Java Enterprise Edition)企业版

                ——为开发企业环境下的应用程序提供的一套解决方案，该技术体系中包含的技术如：Servlet、Jsp等，主要针对于Web应用程序开发

        3）JavaME(Java Micro Edition)小型版

                ——支持Java程序运行在移动终端（手机、PDA）上的平台，对Java API有所精简，并加入对移动终端的支持

4.Java的特点

        1）Java语言是面向对象的(oop)

        2）Java语言是健壮的，Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证

        3）Java语言是跨平台性的

                ——一次编译，到处运行

        4）Java语言是解释型的

                i.解释性语言：编译后的代码，不能直接被机器执行，需要解释器来执行（JavaScript、Java）

                ii.编译性语言：编译后的代码，可以直接被机器执行（C语言、C++）

5.Java的核心机制 - Java虚拟机(JVM：Java Virtual Machine)

        1）JVM是一个虚拟的计算机，具有指令集并使用不同的存储区域

        2）JDK负责执行命令、管理数据、内存、寄存器

        3）对于不同的平台，有不同的虚拟机

        4）Java虚拟机屏蔽了底层运行平台的差别，实现了“一次编译，到处运行”

6.JDK、JRE的关系【面试题】

        1）JDK(Java Development Kit)：Java开发工具包

                —— JDK = JRE + Java的开发工具

        2）JRE(Java Runtime Environment)：Java运行环境

                —— JRE = JVM + Java的核心类库

        3）JDK的下载路径：Java Downloads | Oracle 中国Java Downloads | Oracle 中国Java Downloads | Oracle 中国

7.配置环境变量

        ——在window的设置中，打开系统，点击系统信息，然后点击高级系统设置，再点击环境变量，然后点击新建，把你安装好的JDK的路径，复制到相应的值里面

        如下图：

 

 

 

 

 

 注：这个path和你的系统变量应该处于同一位置，不要一个上一个下

 然后在命令行模式，输出相应的java、javac看看版本号是否和自己安装的版本号一样，若是一样，则环境配置成功！！！

二.Java入门

1.一个小case了解Java的基本框架

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

/*
1.public class Test: 表示Test是一个类，是公开(public)的类
public class Test {}: 表示类的开始和结束

2.public static void main(String[] args): 表示一个主方法，即程序的入口，程序从这个地方开始执行

3.System.out.println(): 输出语句
  System.out.println("Hello World!");//输出Hello World!
  ;(分号)表示语句结束
 */

2.程序的运行原理

                编译(javac)                         运行(java)

Test.java ---------------> Test.class ------------------> 结果

3.一个源文件中最多只能有一个public类，其他类的个数不限，也可以将main方法写到非public类中

public class Test {
    public static void main(String[] args) {
        //一个源文件中最多只能有一个public类，其他类的个数不限，也可以将main方法写到非public类中
    }
}

//错误，一个源文件中只能有一个public类
//public class Animal { }

//可以将main方法写到非public类中
class Animal {
    public static void main(String[] args) {
    }
}

4.Java代码编写的细节说明

1）Java源文件以.java为扩展名，源文件的基本组成是类

2）Java应用程序的执行入口是main()方法，它的形式为：public static void main(String[] args){}

3）Java语言区分大小写

4）Java语言由许多语句构成，每个语句以;结束

5）大括号{}都是成对出现的，缺一不可

//Java源文件以.java为扩展名，源文件的基本组成是类
public class Test {
    //Java应用程序的执行入口是main()方法，它的形式为：public static void main(String[] args]{}
    public static void main(String[] args) {
        
        //Java语言区分大小写
        //以下是三个不同的变量
        int num = 0;
        int Num = 0;
        int NUM = 10;
        
        //Java语言由许多语句构成，每个语句以;结束
        int a = 10;//一条语句，以;结束
        
        //大括号{}都是成对出现的，缺一不可
    }
}

6）一个源文件最多只能有一个public类，其他类的个数不限

7）如果一个源文件包含一个public类，则文件名必须按该类名命名

//如果一个源文件包含一个public类，则文件名必须按该类名(Test)命名
public class Test {
    public static void main(String[] args) {        
    }
}

//不能为public类，一个源文件最多只能有一个public类，其他类的个数不限
//public class Person { }

8）一个源文件中最多只能有一个public类，其他类的个数不限，也可以将main方法写在非public类中，然后指定运行在非public类，这样入口方法就是非public类的main方法

public class Test { }

//一个源文件中最多只能有一个public类，其他类的个数不限
class Person{
    //可以将main方法写在非public类中,然后指定运行在非public类，这样入口方法就是非public类的main方法
    public static void main(String[] args) {        
    }
}

class Animal{}

5.Java中常用的转义字符

\t ：制表位，实现对齐的功能

\n：换行符

\\ ：一个\

\" ：一个"

\' ：一个'

\r ：一个回车

public class Test {
    public static void main(String[] args) {
        //\t ：制表位，实现对齐的功能
        System.out.println("I\thave\tbeen\there");//I  have   been   here
        //\n：换行符
        System.out.println("I am here\n");//I am here
        //\\ ：一个\
        System.out.println('\\');//输出\
        //\" ：一个"
        System.out.println("\"");//输出"
        //\' ：一个'
        System.out.println('\'');//输出'
        //\r ：一个回车
        System.out.println("remember\rlove");//输出love
    }
}

6.注释 

        1）注释类型

单行注释：//【常用于单行代码注解】

多行注释：/* */【常用于对一块代码进行注解】

文档注释：/** */【常对于类和方法的注解】

public class Test {
    public static void main(String[] args) {
        //单行注释：//
        //System.out.println("hello");
        
        //多行注释：/*   */
        /*
        int a = 10;
        int b = 40;
        int c = 50;
         */
    }

    //文档注释：/**  */
    /**
     * 打印
     */
    public static void print() {
        System.out.println("haha");
    }
}

        2）注释的特点

i.被注释的文字，不会被JVM（Java虚拟机）解释执行

ii.多行注释里面不允许有多行注释嵌套

public class Test {
    public static void main(String[] args) {
        //多行注释里面不允许有多行注释嵌套
        /*
        /*
        错误，不能嵌套注释
         */
         */
    }
}

7.Java代码规范

1）类、方法的注释，要使用文档注释的方式写

2）使用tab键，实现缩进，默认整体向右边移动，想要向左边移动使用shift+tab向左移动

3）在使用各运算符的时候，在两边都加上一个空格

int a = 10;//=号两边需要加上一个空格

4）源文件使用utf-8编码方式

5）行宽不要超过80字符

6）代码编写风格有次行风格和行尾风格（推荐）

public class Test {
    public static void main(String[] args) {
        //代码编写风格有次行风格和行尾风格（推荐）
        //1.次行风格
        while(a < 20)
        {
        }
        //2.行尾风格(推荐)
        while(true) {
        }
    }
}

三.变量

1.一个程序就是一个世界

2.变量是程序的基本组成单位

变量三要素：数据类型 + 变量名 = 值;

public class Test {
    public static void main(String[] args) {
        //变量是程序的基本组成单位
        //变量三要素：数据类型 + 变量名 = 值;
        int num = 10;//数据类型：int 变量名：num 值：10
        double data = 20.13;//数据类型：double 变量名：data 值：20.13
        char ch = 'h';//数据类型：char 变量名：ch 值：'h'
    }
}

3.变量的概念

        ——申请了一个变量，相当于变量在内存中申请了一定的空间大小

4.变量的使用步骤

        1）声明变量

int num;//声明了一个变量num,num向内存申请了一个int的空间

        2）赋值

int num;

num = 10;//把10储存在num所占的空间

        3）声明并赋值

int num = 10;//声明了一个变量num,num向内存申请了一个int的空间,把10储存在num所占的空间

5.一个小case快速了解变量

public class Test {
    public static void main(String[] args) {
        int num = 10;//声明并初始化：在内存中申请了一个int的空间存储了10
        char ch = 'a';//声明并初始化：在内存中申请了一个char的空间存储了'a'
        double data = 1.314;//声明并初始化：在内存中申请了一个double的空间存储了1.314

        System.out.println(num);//10
        System.out.println(ch);//a
        System.out.println(data);//1.314
    }
}

6.变量的细节讨论

        1）变量表示内存中的一个存储区域，变量的数据类型不同，占用的空间大小也不同

byte：一个字节（1byte）

char：两个字节（2byte）

short：两个字节（2byte）

int：四个字节(4byte)

long：八个字节（8byte）

float：四个字节(4byte)

double：八个字节（8byte）

boolean：一个字节（1byte）

        2）变量必须先声明，后使用

int a; //声明

a = 10;//使用

//b = 10;//错误，声明在前，使用在后

//int b;

        3）变量的值可以不断的变化

        4）变量在同一个作用域{}内不能重名

public class Test {
    public static void main(String[] args) {
        int num = 10;//声明并初始化：在内存中申请了一个int的空间存储了10

        //变量的值可以不断的变化
        num = 20;
        num = 30;
        num = 40;
        
        //int num = 50;//错误，在同一个作用域{}内，不能申请两个变量名相同的变量
        System.out.println(num);//40
    }
}

        5）变量三要素：数据类型 变量名 = 值;

public class Test {
    public static void main(String[] args) {
        //变量三要素：数据类型 变量名 = 值;
        int data = 10;//数据类型：int  变量名：data  值：10
        System.out.println(data);//10
    }
}

        6）如何查看变量所占的内存空间？ —— 使用各个类型的封装类型

        

public class Test {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //需要找到各个类型的封装类型
        int a=Byte.SIZE;
        int b=Short.SIZE;
        int c=Integer.SIZE;
        int d=Long.SIZE;
        int e=Float.SIZE;
        int f=Double.SIZE;
        int g=Character.SIZE;

        System.out.println("byte型的占用空间--"+a/8+"byte--");
        System.out.println("short型的占用空间--"+b/8+"bytes--");
        System.out.println("int型的占用空间--"+c/8+"bytes--");
        System.out.println("long型的占用空间--"+d/8+"bytes--");
        System.out.println("float型的占用空间--"+e/8+"bytes--");
        System.out.println("double型的占用空间--"+f/8+"bytes--");
        System.out.println("char型的占用空间--"+g/8+"bytes--");
    }
}

7.程序中+号的作用

1）当+号左右两边都是数值的时候，就是简单的基本加法运算

2）当+号的两边有一边为字符串的时候，则做拼接运算，运算顺序为，从左到右

public class Test {
    public static void main(String[] args) {
        //1）当+号左右两边都是数值的时候，就是简单的基本加法运算
        System.out.println(100 + 98);//198

        //2）当+号的两边有一边为字符串的时候，则做拼接运算，运算顺序为，从左到右
        System.out.println("100" + 98); //10098
        System.out.println(100 + 3 + "bro");//103bro
        System.out.println("bro" + 100 + 3);//bro1003
    }
}