返回 登录
0

JAVA之旅(一)——基本常识,JAVA概念,开发工具,关键字/标识符,变量/常量,进制/进制转换,运算符,三元运算

Android老鸟重新学一遍Java是什么感觉?枯燥啊,乏味啊,而且归纳写博客,都是很痛苦的事情,但是程序之路这么长,你必须精通的不能再精通一门语言才行(有点说大了哈),但是最起码你要如鱼得水吧,我准备的资料有:
JAVA编程思想
深入浅出JAVA
黑马,传智,慕课,极客学院等…的视频
Google搜索
我们既然是重新学一遍,那我们尽量就是用记事本去敲代码好了,这里我用notepad++,好了,我们直接开始吧!
一.基本常识

1.什么是软件?

软件:一系列按照特定组织的计算机数据和指令的集合
常用的软件:系统软件
DOS windows Linux等
应用软件:QQ,微信等
软件的出现实现了人与计算机之间更好的交互交互方式
图形化界面:很容易上手的,GUI图像
命令行交互:需要控制台,输入特定的指令,让计算机完成一些操作,比较麻烦
2.CMD命令

这里我列举一些常见的命令,大家以后工作用的上的
dir:列出当前目录下的文件及文件夹(和ls类似)
md:创建目录
rd:删除目录
cd: 进入指定目录
cd ..:退回到上级目录
cd/:退回到根目录
del:删除文件
exit:退出cmd
3.计算机语言

通过Dos命令演示,我们知道操作计算机就是和计算机进行一些交互,像说话一样,我们叫他做什么,他就做什么,前提是你说的指令他能识别,这就是计算机语言,计算机语言种类众多,有C/C++ ,C#,等,而我们要学习的语言是JAVA
二.JAVA概念

1.什么是JAVA

JAVA是sun公司在1995年推出的一门高级编程语言,核心思想就是面向对象,随着JAVA技术在web端的不断成熟,已经成为web人员首选的语言,而且简单易学,安全可靠,跨平台的编程序言
2.三种架构

J2EE 企业版

是为开发企业环境下的应用程序提供的一套解决方案,包含Servlet,JSP,主要针对的是web应用程序
J2SE 标准版

是为开发普通和商务应用给出的解决方案,这也是最基础的,主要做一些小程序
J2ME 家庭版
主要用来开发电子消费产品和嵌入式设备的解决方案,主要应用于小型电子消费类产品,比如手机中的应用程序等
JAVA5.0 里程碑的更新后更名:JAVAEE,JAVASE,JAVAME
3.JAVA特性

java语言的特点,首先说一下跨平台性
什么是跨平台性?
通过java语言编写的应用程序在不同的系统平台上都可用运行
原理是什么?
只需要安装JVM(虚拟机),就可以(JDK中有)
三.开发工具

JDK:http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

下载安装就不说了,多说无益
配置JAVA环境

不多说
我们要验证是否安装成功了,只要在CMD下输入
java jdk
javac 环境
java -version 版本
四.Hello JAVA

这里我就不用开发工具了,我就用notepad++来写了
我们写一段代码:
//公共的 类 类名
public class HelloJAVA{
//公共的 静态 无返回值 main方法 数组
public static void main(String [] str){
//输出HelloJAVA
System.out.println(“HelloJAVA”);
}
}
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
运行的结果

这里有一个细节

我们在cmd中输入
javac HelloJAVA.java
1
1
编译之后会的到HelloJAVA.class,这才是计算机看得懂的语言,我们再输入
java HelloJAVA
1
1
就会输出HelloJAVA了,如上图
五.关键字

JAVA语言的基本组成
关键字
标识符
注释
常量和变量
运算符
语句
函数
数组

我们后面会一个个学的,先来看看大概
abstract 表明类或者成员方法具有抽象属性

assert 用来进行程序调试
boolean 基本数据类型之一,布尔类型
break 提前跳出一个块
byte 基本数据类型之一,字节类型
case 用在switch语句之中,表示其中的一个分支
catch 用在异常处理中,用来捕捉异常
char 基本数据类型之一,字符类型
class 类
const 保留关键字,没有具体含义
continue 回到一个块的开始处
default 默认,例如,用在switch语句中,表明一个默认的分支
do 用在do-while循环结构中
double 基本数据类型之一,双精度浮点数类型
else 用在条件语句中,表明当条件不成立时的分支
enum 枚举
extends 表明一个类型是另一个类型的子类型,这里常见的类型有类和接口
final 用来说明最终属性,表明一个类不能派生出子类,或者成员方法不能被覆盖,或者成员域的值不能被改变
finally 用于处理异常情况,用来声明一个基本肯定会被执行到的语句块
float 基本数据类型之一,单精度浮点数类型
for 一种循环结构的引导词
goto 保留关键字,没有具体含义
if 条件语句的引导词
implements 表明一个类实现了给定的接口
import 表明要访问指定的类或包
instanceof 用来测试一个对象是否是指定类型的实例对象
int 基本数据类型之一,整数类型
interface 接口
long 基本数据类型之一,长整数类型
native 用来声明一个方法是由与计算机相关的语言(如C/C++/FORTRAN语言)实现的
new 用来创建新实例对象
package 包
private 一种访问控制方式:私用模式
protected 一种访问控制方式:保护模式
public 一种访问控制方式:共用模式
return 从成员方法中返回数据
short 基本数据类型之一,短整数类型
static 表明具有静态属性
strictfp 用来声明FP_strict(单精度或双精度浮点数)表达式遵循IEEE 754算术规范
super 表明当前对象的父类型的引用或者父类型的构造方法
switch 分支语句结构的引导词
synchronized 表明一段代码需要同步执行
this 指向当前实例对象的引用
throw 抛出一个异常
throws 声明在当前定义的成员方法中所有需要抛出的异常
transient 声明不用序列化的成员域
try 尝试一个可能抛出异常的程序块
void 声明当前成员方法没有返回值
volatile 表明两个或者多个变量必须同步地发生变化
while 用在循环结构中
六.标识符

在程序中自定义的一些名称
由26个字母大小写,数字,0-9,下划线,美元符
定义合法标识符规则
数字不可以开头
不可以使用关键字
java中严格区分大小写
注意:在起名字的时候,阅读性,尽量有意义
java中名称规范
包名:多个单词组成时,所有的字母小写
类名,接口名:多单词组成时,所有单词首字母大写
变量名和函数名:多单词组成时,第一个单词首字母小写,后面的首字母全- 大写
常量名:所有字母大写
七.常量

固定不变的数据叫做常量
java中常量的分类
1.整数常量:所有整数
2.小数常量:所有小数
3.布尔型常量:true/false
4.字符常量:加一个表示”
5.字符串常量:一个或多个字符双”“
–6.null常量:只有一个数值null
对于整数:java有三种表现形式
十进制 0-9 满十进一
八进制 0-7 满八进一
十六进制 0-9 A-F 满十六进一 用0x开头表示
八进制

进制的由来:
任何数据在计算机中都是以二进制的形式存在的,二进制早期缘由来自开关,一个整数在内存中一样是二进制,但是使用一大串1或者0的数值很麻烦,所以就想缩短一点,将二进制中的三位用一位表示,这三位可以取得的最大值超过7就进一位,这就是八进制,后来慢慢的十进制,十六进制,越来越短了
进制的转换

十进制——>二进制
原理就是对十进制进行/2 运算,我们可以这样去计算
比如6:6/2 = 3 余 0
3 / 2 = 1 余 1
那就是从个位数开始011,读起来就是110了
而在JAVA中,其实可以直接用代码换算的,我们可以这样写
//公共的 类 类名
public class HelloJJAVA{
//公共的 静态 无返回值 main方法 数组
public static void main(String [] str){
//输出6的二进制转换
System.out.println(Integer.toBinaryString(6));
}
}
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
还是用回Eclipse,不然不习惯了,嘿嘿
输出的结果

二进制——>十进制
既然2可以转10,那10也可以转2,原理都是相同的, 你除,我乘,二进制转十进制也很简单,我们以上面那个6的二进制110为例
二进制110转换成十进制
0*2的0次方 + 1*2的1次方 + 1*2的2次方
0 + 2 + 4 = 6
二进制——>十六进制
我们拿90来换算,转换成二进制是01011010,我们看图

我们知道二进制每四位就是一个16位,这样我们就可以拆分。让四位去二进制,然后算出来的10在16位中是A表示,所有是0x5A
这样的话,二进制转八进制就更简单了,直接每三位换算,不足三位的前面补0也可以
这里还有一个要注意,就是负数的二进制转换,其实就是取反+1,怎么个说法?就是0转换成1 1 转换成0 结果+1 就得出了
九.变量

在变量了解之前,我们先了解一下一个概念——数据类型
数据类型

Java基本类型共有八种,基本类型可以分为三类,字符类型char,布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的,它们的取值范围是固定的,不会随着机器硬件环境或者操作系统的改变而改变。实际上,JAVA中还存在另外一种基本类型void,它也有对应的包装类 java.lang.Void,不过我们无法直接对它们进行操作。8 种类型表示范围如下:
byte:8位,最大存储数据量是255,存放的数据范围是-128~127之间。
short:16位,最大数据存储量是65536,数据范围是-32768~32767之间。
int:32位,最大数据存储容量是2的32次方减1,数据范围是负的2的31次方到正的2的31次方减1。
long:64位,最大数据存储容量是2的64次方减1,数据范围为负的2的63次方到正的2的63次方减1。
float:32位,数据范围在3.4e-45~1.4e38,直接赋值时必须在数字后加上f或F。
double:64位,数据范围在4.9e-324~1.8e308,赋值时可以加d或D也可以不加。
boolean:只有true和false两个取值。
char:16位,存储Unicode码,用单引号赋值。
Java决定了每种简单类型的大小。这些大小并不随着机器结构的变化而变化。这种大小的不可更改正是Java程序具有很强移植能力的原因之一。下表列出了Java中定义的简单类型、占用二进制位数及对应的封装器类。

对于数值类型的基本类型的取值范围,我们无需强制去记忆,因为它们的值都已经以常量的形式定义在对应的包装类中了。如:
基本类型byte 二进制位数:Byte.SIZE最小值:Byte.MIN_VALUE最大值:Byte.MAX_VALUE
基本类型short二进制位数:Short.SIZE最小值:Short.MIN_VALUE最大值:Short.MAX_VALUE
基本类型char二进制位数:Character.SIZE最小值:Character.MIN_VALUE-最大值:Character.MAX_VALUE
基本类型double 二进制位数:Double.SIZE最小值:Double.MIN_VALUE最大值:Double.MAX_VALUE
注意:float、double两种类型的最小值与Float.MIN_VALUE、 Double.MIN_VALUE的值并不相同,实际上Float.MIN_VALUE和Double.MIN_VALUE分别指的是 float和double类型所能表示的最小正数。也就是说存在这样一种情况,0到±Float.MIN_VALUE之间的值float类型无法表示,0 到±Double.MIN_VALUE之间的值double类型无法表示。这并没有什么好奇怪的,因为这些范围内的数值超出了它们的精度范围。
Float和Double的最小值和最大值都是以科学记数法的形式输出的,结尾的”E+数字”表示E之前的数字要乘以10的多少倍。比如3.14E3就是3.14×1000=3140,3.14E-3就是3.14/1000=0.00314。
Java基本类型存储在栈中,因此它们的存取速度要快于存储在堆中的对应包装类的实例对象。从Java5.0(1.5)开始,JAVA虚拟机(Java Virtual Machine)可以完成基本类型和它们对应包装类之间的自动转换。因此我们在赋值、参数传递以及数学运算的时候像使用基本类型一样使用它们的包装类,但这并不意味着你可以通过基本类型调用它们的包装类才具有的方法。另外,所有基本类型(包括void)的包装类都使用了final修饰,因此我们无法继承它们扩展新的类,也无法重写它们的任何方法。
基本类型的优势:数据存储相对简单,运算效率比较高
包装类的优势:有的容易,比如集合的元素必须是对象类型,满足了java一切皆是对象的思想

数据类型了解之后我们就来说下变量了
变量的概念

就是将不确定的数据进行存储,也就是需要在内存中开辟一个空间
我们该如何去定义一个变量?我们以整数为例
int num = 5 ;
//变量是可以复用而且重复赋值的,我们可以来测试一下
//公共的 类 类名
public class HelloJJAVA {
// 公共的 静态 无返回值 main方法 数组
public static void main(String[] str) {
// 定义一个变量
int num = 5;
System.out.println(num);
num = 10;
System.out.println(num);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
6
7
8
9
10
11
12
13
输出的结果

十.类型转换

我们直接看例子
//公共的 类 类名
public class HelloJJAVA {
// 公共的 静态 无返回值 main方法 数组
public static void main(String[] str) {
byte a = 2;
a = a + 5;
System.out.println(a);
}
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10
这样是不能输出,因为不是同一类型,原则是以大的为主,强制类型转换,我们应该这样写
a = (byte) (a + 5);
1
1
在工具中会提示,但是我们基本知识要掌握
十一.运算符

我们数据类型也有了,变量也有了,那我们就可以开始运算了,常见的运算符有以下几种
算术运算符
赋值运算符
比较运算符
逻辑运算符
位运算符
三元运算符
我们先来看看第一种
算术运算符

这个说了跟没说一样,就是加减乘除+ - * /
我们写个小例子
//公共的 类 类名
public class HelloJJAVA {
// 公共的 静态 无返回值 main方法 数组
public static void main(String[] str) {
int a = 10;
int b = 5;
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
得到的结果小学生都会了

但是所有的运算符都是有优先级的

而且连算的时候会出问题,我们写个例子
//公共的 类 类名
public class HelloJJAVA {
// 公共的 静态 无返回值 main方法 数组
public static void main(String[] str) {
int a = 8510;
a = a / 1000 * 1000;
System.out.println(a);
}
}
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
你一看,我去,真当我小学没毕业呢,8510除以1000再乘以1000不还是等于8510吗?我微微一笑,我们看输出的结果

你一看就傻眼了,这是为什么?因为从左到右的顺序去计算的话,8510/1000 是8.51,但是8.51有小数点,不是int类型,就自动转换成int类型了,也就是8 ,然后8再乘以1000不就是8000,这里稍微注意一下就可以了

我们再来讲一个重要的知识点——取模(%)
其实说白了就是去余数
//公共的 类 类名
public class HelloJJAVA {
// 公共的 静态 无返回值 main方法 数组
public static void main(String[] str) {
int a = 11;
System.out.println(a%2);
}
}
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
像这样,其实就是11%2,也就是11/2 = 5 余1 ,那么11%2 = 1;我们看下结果

左边 < 右边 = 左边
左边 = 右边 = 0
左边 > 右边 = 余数
比如++ – 什么的,就是自增1,自减1,没什么可讲的了
不过有一点还得注意,就是+,在计算的时候+是运算符,但是在字符串中,是连接符的意思,我们举个例子
//公共的 类 类名
public class HelloJJAVA {
// 公共的 静态 无返回值 main方法 数组
public static void main(String[] str) {
int a = 2;
int b = 5;
System.out.println(a + b);
String c = “你好”;
String d = “Android”;
System.out.println(c + d);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
结果显而易见

转义字符

这是一个小知识点
换行\n
空格\t
退格\b
制表符\t 相当于Tab键
通过\转换后面字符的含义
赋值运算

就是 = 号,赋值,这里有些特殊的,+= -= *= /=,这些是什么意思呢?我们比较一下
a += 5;
a = a + 5 ;
比较运算符

这里,没什么讲的,> <之类的,我们这里有一个常用的 == ,就是相等于的意思,比较
3 == 4 false
4 == 4 true
主要是判断两个是否相等
逻辑运算符

这个算是比较难的了
这里写图片描述

&
int x = 4;
//逻辑运算符连接布尔类型的表达式
x>3 & x<6 true = true;

    /**
     *  true & true   true
     *  true & false  false
     *  false & true  false
     *  false & false false
     *  总结:&符号就是你两边都是true才成立,换句话说,两边只要有一个false,就是false
     */

1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
|
/**
* | 是什么?
*
* true | true true
* true | false true
* false | true true
* false | false false
*
* 总结:只要就一个成立就可以,也就是返回true,只有当两个都是false才会返回false
*/
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11
^
和|差不多,但是
true ^ true false
!

非,就是不是的意思
int a = 5;
a != 6; a 不等于 6
&&

这个也好理解,只要左边的是false,后面就不运算了
||

这个当左边为true的时候,后面不运算
位运算符
这个位是二进制计算

我们一个个来解析
3 << 2 = 12 怎么去算的?
我们先把3换算成二进制就是11 ,那前进而且,后面补两个0

得带1100,换算就是12了
最高位补什么由原来数据的最高位值而定,如果最高位是0,右移后,用0补空位,如果最高位是1,右移后,由1补空位
当然,&和|也可以作为位运算的
也就是换算二进制在进行&,0是假,1是真,得到的二进制再换算成十进制就可以了‘
我们这里做一个小练习
题目:

1.最有效的方式算出2乘以8等于几?
2.对两个整数变量的值进行交换(不需要第三方变量)
第一题:

2*8不就是16,嘛,但是你要知道这个是最有效的,也就是效率,他们计算实际上在内存中也是转换成二进制进行计算的,而有效的,莫过于位运算了,答案是
2<<3
这样就可以高效的得到16了
第二题

看例子

//公共的 类 类名
public class HelloJJAVA {
// 公共的 静态 无返回值 main方法 数组
public static void main(String[] str) {
// 进行互换
int a = 10;
int b = 5;

    System.out.println("a:" + a + "\n" + "b:" + b);

    /**
     * 第一种方式:第三方变量
     */
    int temp;
    temp = a;
    a = b;
    b = temp;

    System.out.println("a" + a + "\n" + "b:" + b);

    /**
     * 第二种方式:不用第三方变量 其实可以利用他们的和的
     */
    a = a + b;
    b = a - b;
    a = a - b;

    System.out.println("a" + a + "\n" + "b:" + b);

}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
当然,我们也可以运用我们的^
a = a ^ b;
b = a ^ b;
a = a ^ b;

    System.out.println("a" + a + "\n" + "b:" + b);

1
2
3
4
5
6
1
2
3
4
5
6
有点搞晕了
三元运算符

格式
(条件表达式)?表达式1:表达式2
如果条件为true,运算后的结果为表达式1
如果条件为false,运算的结果就是表达式2
表达式就是true或者false,我们举个例子
//公共的 类 类名
public class HelloJJAVA {
// 公共的 静态 无返回值 main方法 数组
public static void main(String[] str) {

    int a = 10;
    // 如果a大于20就给b赋值30否则就60
    int b = (a > 20) ? 30 : 60;
    System.out.println(b);
}

}
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
结果’

好的,我们的JAVA基础算是入门了,但是这只是九牛一毛,我们真正的好东西,下篇博客会开始慢慢的接触

评论