初学JAVA
Java 特点： 1995年正式发布Java
1跨平台性、2简单性（较C++）、3纯面向对象 （4开源）
------------------------------------------------------
1.简单性
舍弃了运算符重载、多继承等不常用的、难以理解的、容易混淆的成分
增加了自动垃圾搜集功能，用于回收不再使用的内存区域，大大减少了由于内存分配而引发的问题
另外，简单性还体现在小上。Java解释器、系统模块和运行模块都比较小，适合在小型机器上运行，也适合在网上下载
2.面向对象
面向对象编程是一项有关对象设计和对象接口定义的技术，或者说是一项如何定义程序模块才能使它们“即插即用”的技术。
Java继承了C++面向对象技术的核心，更具有动态解决问题的特性。
对象通过继承和重定义，成为解决新问题的棋块，使代码重用有了可能。
3.网络适用性
Java提供了大量的系统模块支持基于TCP/IP协议的编程，使得Java建立网络连接更容易
Java程序通过URL访问网络资源和存取本地文件系统一样简单。
4.健壮性
Java提供早期的编译检查和后期的动态(运行期）检查，大量消除了引发异常的条件.
5.安全性
Java可以组建病毒无法入侵和无法篡改的系统，其数字验证使用了基于公共密钥的技术。
安全性和健壮性密切相关
6.结构中立
任何安装了Java运行环境的计算机都能执行Java编译生成的目标代码(字节码)。
7.可移植性
结构中立构成了可移植性的基础
Java语言的基本数据类型采取固定长度，例如int型数据在任何计算机上都是32位长(4个字节)
Java提供了可移植的接口
java本身也可以移植
8.解释型
Java是解释执行的。执行速度可以很快
9.高性能
字节码翻译执行很快
10.多线程
计算机同时运行多个程序段
Java提供了一套复杂的线程同步化机制，程序员可以方便的使用基于这种机制设计的方法，编写出健壮的多线程程序。
11.动态
Java是运行加载，类库可以自由添加方法和属性而不影响用户程序
Java运行机制：
编译 编译器：源文件 --> 机器码文件 （运行效率高）
解释 解释器：源文件 --> 逐行翻译并运行 （可以跨平台）
Java ———— 先编译 后解释
.java 源文件 --> .class 字节码文件 --> 在解释器中 解释运行
JVM：Java虚拟机 屏蔽不同操作系统（OS）的差异
JVM + 解释器 = JRE （Java运行环境）
编译器+JRE+工具+类库 = JDK （Java开发工具包）
Java运行过程：
1、编译命令：javac 源文件名.java ———— 几个类编译后就会生成几个.class（文件名相对应）
2、运行命令：java 类名（一个类的全名）（包名.类名）
一个源文件可以定义多个类(class)
一个源文件只能定义一个公开类(public class)，公开类的类名必须和源文件名称完全相同
包：
package 包 ———— 写在程序第一句话 ———— 多个包用.隔开 如 package p1.p2.p3;
java p1.Hello
--> JVM会根据ClassPath（.）在当前目录下，找p1子目录，并在这个子目录中找Hello.class
javac –d 目标目录 源文件名.java
目标目录 --> 把生成的目录放在哪个目录下作为子目录。
javac -d . Hello.java ———— 生成的class自动放入包里（.指把包放入当前目录下）
import 引入包，目的是避免重复写包名 —————— 书写在package之后 —— 让代码更简洁，可不写
*包里的所有类，但是不包括子包（即不能写.*.*）
import java.lang.*; 系统默认添加
java.lang.String
java.lang.System
基本结构：
package:0-1
import: 1-n
class: 1-n 公开类 0-1
注释：
描述代码的文字 提高代码的可读性和可理解性
1. // 单行注释 （//往后） 写在代码的上部或后面
2. /* */ 多行注释 （里面允许嵌套单行注释，但不允许嵌套多行注释）
3./** */ 多行注释 配合JavaDoc工具使用 —— 写在需注释的前面 ———— 生成API文档
标识符_语法（必须）：
1. 字母(中英文) 数字 _ $
2. 数字不能开头
3. 大小写敏感
4. 不能使用关键字和保留字 package import class public true false
5. 没有长度限制
标识符_习惯：
1. 望文生义 提高可读性
2. 大小写
包名：全小写 com.baizhi.day2;
类名：单词首字母大写 HelloWorld
变量/函数名：首单词小写，后面的单词首字母大写 printStar
常量名：全大写 COUNT //下划线常用于常量名的单词分隔
数据类型 变量
数据类型：对象类型：无穷，定义的类class；
简单类型（基本类型、原始类型）：8种
整型：
byte 1B -128 ~ 127
short 2B -32768 ~ 32767
int 4B -2147483648 ~ 2147483647
long 8B -2^63 ~ 2^63-1 字面值后加l或L
浮点型： 科学计数法 如 1.4e10=1.4*10^10
float 4B 单精度 必须字面值后加f或F
double 8B 双精度 字面值后加d或D
字符型：
char 2B 用法 'A' 65 '\u0041' --（\u后加16进制）
unicode编码方式 如 'A'=65
char类型可以进行数学运算 char('A' + 'B')=131;
转义字符 '\t' 跳格tab
'\n' 换行
'\'' 打印‘
'\“' 打印“
'\\' 打印\
boolean 布尔类型 字面值 true false
java中boolean类型不能参与运算
String 字符串 字面值 "HelloWorld"
只能参与加法运算 如"a"+"b"="ab" "ab"+10="ab10"
java 强类型 变量类型必须和数据类型一致 (int a=1.5 --> a=1)
定义变量：变量类型 变量名；
类型转换：(类型)表达式
自动类型转换 提升精度
强制类型转换 丢失精度 short i = short(int a)
a + b 自动类型提升
若a和b中有double ==> double
若a和b中有float ==> float
若a和b中有long ==> long
默认 ==> int
只要有String ==> String
表达式
变量和字面值用某个运算符连接的式子
表达式必须有固定的值
运算符
+ - * / %
= += -+ *= /= a+=3 不会类型提升 == a=a+3 会类型提升
%= a=4 a++ --> a=5 -->表达式=4 先赋值再+1
a=4 ++a --> a=5 -->表达式=5 先+1再赋值
== > < >= <= !=
&&逻辑与 ||逻辑或 !逻辑非 ——— 只能进行逻辑运算，短路性 比如判断&&前面为false后，直接进行最终判断
&按位求与 |按位求或 ^异或 ~求反(1变0,0变1) -- 前三个也可以参与逻辑运算
(1&1为1，其他都为0) ^ 相同为0,不同为1;
^ 参与逻辑运算时，同为真或假时，返回假，其他返回真
>> << >>> 移位运算符 10110>>1 --> 01011 右移一位除以2
10110<<1 --> 01100 左移一位乘以2
>> 算术右移 有符号的位移，保持符号不变
>>> 逻辑右移 负数位移完变正数
?: 三元操作符 如：(a>b)?3:2 ——> 判断a>b,true-->3,false-->2
局部变量 在函数内部定义的变量
1.先赋值，后使用
2.作用范围：从定义开始，到它的代码块结束 //{}：一个代码块
3.在作用范围内，不允许两个局部变量发生命名冲突
读入数据
读入数据的类： java.util.Scanner
代码：
java.util.Scanner sc = new java.util.Scanner(System.in); //创建了一个 Scanner 对象,,为读入数据做准备
int n = sc.nextInt(); //读入一个整数
String str = sc.nextLine(); //读入一行字符串
double d = sc.nextDouble(); //读入浮点数
/*通过sc的相关函数 从控制台获取数据
next() 获取字符串 遇到空格或者回车结束
nextLine() 获取字符串 遇到回车结束
nextInt() 获取一个int类型的数据
nextDouble() 获取一个double类型的数据
nextBoolean() 获取一个boolean类型的数据
next().charAt(0) 获取一个字符
*/
流程控制
顺序执行流程
条件分支流程
if(){}
if(){} else{}
if(){} else if(){} else{}
switch(i){
case 1: ;break; //case后面的常量必须是整数或字符型
case 2: ;break; //case后面的常量不能有相同的值
case 3: ;break; //case后面通常使用break，提供一个出口，否则会落空
……
default: ; —— 前5个case都不能匹配的时候，执行default。
}
switch(i) —— i：只允许整型表达式 byte short int char
后续版本已支持 String
case后只能跟数字，不能跟范围
循环流程
while(布尔表达式){} 会执行0~n次
do{}
while(布尔表达式); 会执行1~n次
for(①赋值;②⑤⑧条件;④⑦语句){③⑥} 会执行0~n次
条件为空时，默认true；
for( ; ; )里面都可为空
确定循环次数时适合用for循环
break; 跳出循环
continue; 跳出本次循环/继续下一次循环
双重循环 循环的嵌套
函数(方法)：
可以重复被使用的一段代码
定义位置：类中，其他函数的外部
一个类中，多个函数的顺序是无关紧要的
声明： public static 返回值类型 函数名（形参列表）
返回值:表示调用函数之后，函数会返回什么数据给调用者；(8种基本类型+对象类型)
形式参数（形参）：相当于函数内部有效的局部变量 ———— 多个形参用“,”隔开 如(int a,int b)
void 表示没有返回值
实现：{代码}
必须和声明一致（主要指返回值类型）
return;
return 语句表示返回一个值
还能够控制流程的跳转(结束函数)
调用函数：
函数名(实参列表);
实参会依次给形参赋值，，实参(表达式，字面值，变量)
调用函数，程序流程会进入函数，函数返回，程序流程会返回到函数调用点
函数的作用：
1.避免冗余代码
2.提高程序的可维护性
3.提高程序的重用性
4.提高程序的灵活性
函数的嵌套和递归
递归：函数自己调用自己 不是必须用
把一个大问题化解成小问题
编程思想：
面向过程的编程：（自顶向下，逐步求精）
从程序执行的过程入手，将完整的过程细化成多个子过程，再将子过程细化，直到完成代码
非结构化： goto
结构化： 函数
一维数组：一个线性数据序列 (数组是有序元素的集合)
一次性定义多个同类型的变量 int[] a;
数组空间在内存中必定是连续的
数组元素有默认值
数值类型数组 默认值：0/0.0
boolean类型数组 默认值：false
对象类型数组 默认值：null
int[] a = {1,2,3}; 数组的显式初始化
||
int[] a = new int[] {1,2,3}; 数组的显式初始化
||
int[] a; 数组的定义声明
a=new int[3]; 初始化长度
a[0]=1; 数组中变量的赋值
a[1]=2;
a[2]=3;
for(int i = 0;i<a.length;i++){ //遍历数组：把数组中的元素从头到尾访问一遍
System.out.println(a[i]);
}
数组的长度： 数组名.length
数组长度是固定的，如果需要扩充，必须创建新数组，原数组的元素要复制到新数组
数组的扩充1：int[] a={1,2,3,4};
int[] b=new int[a.length*2];
for(int i=0;i<a.length;i++){
b[i]=a[i];}
a=b; //让a这个变量自此指向b地址,即把b指向的首地址赋值给a
数组的扩充2：int[] a={1,2,3,4};
int[] b=new int[a.length*2];
System.arraycopy(a,0,b,0,a.length); //System.arraycopy(原数组，起始下标，目标数组，起始下标，数量)
a=b;
数组的扩充3：int[] a={1,2,3,4};
a=java.util.Arrays.copyOf(a,a.length*2);
二维数组：(机器识别为：一维数组的嵌套)
int[][] a = new int[4][3]; 4行3列
for(int i=0;i<a.length;i++){ //遍历数组
for(int j=0;j<a[i].length;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
不规则数组:
int[][] a = new int[4][] //先为数组指定高维长度，再分别指定低维长度。但是反过来是错误的。
a[0]=new int[3];
a[1]=new int[5];
a[2]=new int[2];
a[3]=new int[6];
int[][] a = {{1,2,3},{4,5,6},{7,8,9},{0,0,0}}; 二维数组的显式初始化
数组的排序：(归纳法)
冒泡排序法：两个相邻的元素相比较
int[] a={4,2,7,6,9,1,5};
int n = a.length;
for(int i=1;i<n;i++){ //外循环
for(int j=0;j<(n-i);j++){ //内循环
if(a[j]>a[j+1]){ //相邻两个，前面数值较大时
int t = a[j]; //交换a[j]和a[j+1]的位置
a[j] = a[j+1];
a[j+1] = t;
}
}
}
选择排序法：选择一个元素后和其余元素相比较
//第一种：
int[] a={4,2,7,6,9,1,5};
int n = a.length;
for(int i=0;i<(n-1);i++){ //外循环
for(int j=i+1;j<n;j++){ //内循环
if(a[i]>a[j]){ //选择的元素与其余元素比较时，前面数值较大时
int t = a[i]; //交换a[i]和a[j]的位置
a[i] = a[j];
a[j] = t;
}
}
}
**//第二种：**
int[] a={4,2,7,6,9,1,5};
for(int i = 0;i<a.length-1;i++){
int min = i; //min保存遍历范围内的最小值的下标
for(int j = i;j<a.length;j++){
if(a[min]>a[j]){
min = j;
}
}
//a[i] <==> a[min];
int temp = a[i];
a[i] = a[min];
a[min] = temp;
}
**快速排序法：**
java.util.Arrays.sort();
快捷键
加粗
Ctrl + B斜体
Ctrl + I引用
Ctrl + Q插入链接
Ctrl + L插入代码
Ctrl + K插入图片
Ctrl + G提升标题
Ctrl + H有序列表
Ctrl + O无序列表
Ctrl + U横线
Ctrl + R撤销
Ctrl + Z重做
Ctrl + Y
扫一扫
2518
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
