core java 1~4(HelloWorld & 标识符|关键字|数据类型 & 表达式|流程控制 & 数组)

MODULE 1

Java的编译和运行
----------------------------
编译：javac -d bin src\HelloWorld.java
-d:指定编译后的class 文件的存放路径
若在此 .java文件的类中，调用了另一个文件的类，则需先编译被调用的类，然后输入
javac -d bin -cp bin src\HelloWorld.java
或者编译所有 .java文件 javac -d bin src\*.java

运行：java -cp bin com.briup.ch01.HelloWorld
-cp:指定class文件的搜索路径

java源文件中的三要素：
-------------------------
1）package
语法：package com.briup.ch01;
编译后以目录的形式出现
package不是目录
编译后完整的类名：包名+类名 com.briup.ch01.HelloWorld
2)import
可有可无
java.lang包中的类或者同一个包中的类无须import
3)类定义
class 类名{...}
类名要求首字母大写；保留好的习惯
一个java源文件中允许定义多个类，但是只能有一个public修饰的类
public类的类名必须和源文件的文件名相同

字节码校验器
--------------------------------
1）验证JVM版本的兼容性
2）检验代码不会破坏系统的完整性
3）不会在内存中造成栈上溢或下溢
4）方法调用过程中，参数类型要检验
5）数据类型转换要正确

类加载过程
---------------------------
1.类加载器分类
1）启动类加载器bootstrap class loader
加载jdk的核心类库
%JAVA_HOME%jre/lib/rt.jar
2）扩展类加载器extensible class loader
加载一些第三方的扩展类库
%JAVA_HOME%/jre/lib/ext/*.jar
3）系统类加载器system class loader
加载自定义的类
2.类加载流程
——>启动类加载器——> 扩展类加载器——>系统类加载器
双亲委托机制
java com.briuch01.HelloWorld

优势:1）可以避免类的重复加载，当上一级已经加载时，就不会到下一级加载同名的类
2）考虑安全性，避免自定义的类任意覆盖java的核心类库

打jar包
jar -cvf helloworld.jar com
-c creat
-v 显示过程
-f 指定文件名
解压jar包
jar -xvf helloworld.jar

jdk中常用的包
----------------------
java.lang 常用的类
java.awt/javax.swing/java.awt.event
图形用户界面的开发
java.io 输入，输出
java.net 网络编程
java.util jdk提供的常用工具类

 

MODULE 2标识符 关键字 数据类型
---------------------------------------------------------------

注释：
------------------
单行注释
//注释内容
多行注释
/*
多行注释内容
*/
javadoc文档注释（源程序中推荐使用）
/**
注释内容
*/
产生html格式的javadoc文档
常见的语法：
@author 作者
@version 版本
@since 标注哪一个版本的jdk
@param 参数
@return 返回类型
@throws @Exception 异常信息的描述
命令： javadoc -d doc src\*.java
产生作者和版本号： javadoc -d doc -author -version src\*.java

编码注意事项
----------------
1）每条语句以";"结束，建议每行只写一个语句，注意缩进
2）java中所有代码要写咋代码块{}中
3）代码间的分割：空格 制表符tab 换行符 续行符

标识符
----------------------------
命名类，方法，变量
1）以字母，"$"开头，不能以数字开头
2）大小写敏感
3）没有长度限制
4）回避使用关键字

关键字
-----------------------------
1）goto const 不属于关键字列表，称为保留字，回避使用
2）true false null具有特殊含义，也要避免使用

1.基本数据类型
-----------------------
四类八种：整型 浮点型 布尔型 字符型

boolean
true / false
不能为0和1

char
无符号16bit整型
1）单引号表示 char c='A';
2）ASCII码表示 char c=97;
3)unicode编码表示 char c='\u0060'

String:
不是基本数据类型，属于引用类型
表示多个字符的集合

整型
byte short int long
默认是int类型，long型要在后面加L或l
1)八进制Octal
前面加0 如 010===> 0*8^0 +1*8^1 ===> 8
转换成二进制： 0 ---> 000 1 ----> 001 ===>001000 ---->8
2)十进制Decimal
java中整型数默认为十进制int型数据
3）十六进制Hexadecimal
前面加0x 如 0x10
换算成十进制： 0*16^0 + 1*16^1 ===>16
换算成二进制： 0--->0000 1--->0001 ===>00010000 ---->16

浮点型
float double
3.1415
1）默认是double类型
2）float型一"f"或"F"结尾
3）double型以"d"或"D"结尾

数据类型间的转换
1.隐式转换
byte/short/char ----> int -----> long ======> float ----> double
byte/short/char 之间是平级的，不能自动转换的
short i=99;
char c=i;//错误
char c=(char)i;
---------------
short s1=1;
s1=s1+1;//错误
2.强制类型转换
大类型转换为小类型，需要强制类型转换
语法：（转换的目标类型）原数据类型
问题：会存在精度的丢失

命名规则
1）类名/接口名称：开头大写
2）方法：开头小写，后面首字母大写
3）变量：开头小写
4）常量：全部大写

java中的内存分配
---------------------------
堆区：所有程序共用，空间不连续，容量大速度慢
通常用于存放创建出的对象（new），成员变量等
栈区:先进后出的分配原则，存储空间连续，容量小速度快
通常用于存放局部变量和基本数据类型变量等
代码区：存放代码块，方法体等
静态/常量区：存放静态变量，常量等

int i=(int)(char)(short)(byte)-1;
负数的存储方式：补码

类class：
现实世界对象---（抽象）---->类
1)生活中：
同类型的一个群体所具有的共同特征和共同行为
2）程序中
class Person{
//共同特征-->成员变量
int age;
//共同行为-->普通方法
public void eat(){}
}

对象Object
1)生活中
群体中一个独立的个体
2）程序中
类的一个实例化对象
Person zhangweiwen;//声明一个引用型变量
zhangweiwen=new Person();//创建Person类对象，并返回引用
zhangweiwen.eat();

若CatTest.java中调用了文件外的class文件
编译CatTest.java:
先编译调用的那个class
然后javac -d bin -cp bin src\CatTest.java

构造器
对类中的成员变量进行初始化，不属于类的行为
定义时与类名相同，且没有返回类型
public Cat(String atype,String aname,int aage,String acolor){
type=atype;
name=aname;
age=aage;
color=acolor;
}

引用型变量
要使用一个对象时，要给该对象一个唯一的标识
变量名.成员变量 ---> 访问对象的属性
变量名.方法（） ----> 访问对象的行为

作业：
自定义矩形类Rectangular.java
成员变量：长 宽
构造器：无参构造器
有参构造器
方法：求周长，打印输出
求面积，打印输出
定义测试类RectangleTest.java
main:
创建多个矩形对象（采用构造器方式创建）
分别调用方法打印输出周长和面积

MODULE 3表达式和流程控制
----------------------------
局部变量：定义在方法内部的变量，没有默认的初始化值，在使用前必须赋值
作用域范围仅限方法内部，方法执行完空间就回收

引用类型初始化
Student li=new Student();
String str1=new String("hello"）；
String str="hello";//特别，允许以基本类型方式赋值
new String("hello");

成员变量
定义在类的内部方法的外部
具有默认的初始化值
整型：0
浮点型：0.0
字符型：‘\u0000’
boolean:false
引用类型（reference type）：null

class Person{
//成员变量
String name;
in age;
void addAge(int n){
age +=n;
}
}

Operators运算符
-----------------------
算数运算符：加 减 乘 除 取余
运算符两边的数据类型要一致，否则小类型默认转换为大类型

赋值运算符

比较运算符 结果为boolean类型 true 或false

移位操作符：针对数据的二进制串进行操作
右移 >> 负数最高位补1 即最高位补符号位
3>>2 将3 的二进制数右移2位
左移<<
无符号右移>>> 最高位符号位补0

位运算符
--------------------------
位与 & 两个都为1，结果才为1 否则结果为0
位或 | 只要有一个为1，结果为1
异或 ^ 相同为0，不同为1
取反 ~

逻辑操作符 参与运算的都是布尔型数据
---------------------
逻辑与&&
A && B A和B都为true时，结果才为true
短路规则：当A为false时，B不参与运算
逻辑或||
A || B A或B中只要有一个为true，结果为true
短路规则：当A为true时，B不参与运算

条件运算符
A?B:C
如果A为true，表达式结果为B，否则为C
注意：冒号两边数据类型不一致时，小类型自动转换为大类型,最终结果为大类型

流程控制语句
---------------------------------
switch & case
switch(temp)
1.要求temp为byte short char int,枚举（jdk1.5）
2.case是条件分支的入口，一旦进入，就会一直执行下去，直到break
3.default可放在switch中的任意位置

循环语句
-----------------------
1.for循环
2.while循环
3.do-while循环

MODULE 4 数组
------------------------
数组是一种数据结构
用于存储 指定长度 的 相同类型 数据的 集合
1）相同类型数据
声明时就必须指定数组中元素的类型
2）指定长度
数组长度一旦定义好，就不能再更改
3）属于引用类型
必须使用new进行创建，属性石length

声明
--------------------------
1.元素是基本数据类型
int[] iArray; int iArray[];
声明是只指定元素类型，不指定数组长度
2.元素是引用类型
Student[] iArray; Student iArray[];

创建
--------------------------
1)使用new关键字创建数组对象
2）指定该数组的长度（允许存放元素的最大个数）
3）数组中的元素需要单独创建
4）数组中的元素有默认的初始化值
语法：
1）基本数据类型
int[] iArray=new int[3];
2）引用类型
//创建数组，但里面的学生对象并未创建
Student[] iArray=new Student[5]
//创建一个学生对象
Student s1=new Student();

元素的初始化
-------------------
默认初始化：
显式初始化
1）声明，创建和初始化分开
2）同时声明，创建和初始化
int[] iArray=new int[]{2,3,4};//正确

int[] iArray; iArray=new int[]{5,6,7};//正确

int[] iArray=new int[3]{2,3,4};//错误

int[] iArray={5,6,7};//正确

int[] iArray; iArray={5,6,7};//错误
引用类型
Student[] iArray=new Student[3];
Student s1=new Student("jeffrey");
iArray[0]=new Student("jeffrey");

Student[] iArray=new Student[]{
new Student("jim"),
new Student("ann")};
Student[] iArray={
new Student("jim"),
new Student("ann")};

Student[] iArray;
iArray={
new Student("jim"),
new Student("ann")};

数组元素的访问
----------------------------------
语法：数组名[元素下标]
元素下标的范围：0~length-1

数组的遍历
-----------------------------------
int[] iArray=new int[100];
算法：for(int i=0;i<iArray.length;i++){iArray[i]=i;}

数组在内存中的存储方式
一段地址连续的线性存储空间
1）基本数据类型
变量和数据都存放在栈区
int[] array=new int[]{1,5,23,35};
2）引用类型
变量存储在栈区，元素对象存放在堆区

多维数组
-----------------
java中的数组都是一维数组，所谓多维数组表示的是数组的数组
维度最多可以定义255维
一维数组 表示线性的数据
二维数组 表示平面

二维数组分类：
1.对称数组（矩阵）
int[][] array=new int[2][3];//创建一个二维数组array，两行三列
2.非对称数组（锯齿形）
1）第一个维度一定要在创建时确定
int[][] array=new int[3][];
2)每个元素都是一个一维数组，需要单独创建
array[0]=new int[3];
array[1]=new int[5];
array[2]=new int[2];
***
*****
**
3)array.length=3;//=行数=第一维度
array[0].length=3;//每一行的元素个数
array[1].length=5;

访问二维数组的每个元素
array[0] 代表第一行
array[0][0] array[0][1] array[0][2]

遍历二维数组
for(int i=0;i<array.length;i++){
for(int j=0;j<array[i].length;j++){
System.out.print(array[i][j]);
}
}

数组的拷贝
-------------------------
间接实现数组长度的扩充

source array ----------> dest array

System.arraycopy(from,fromindex,to,toindex,length)

知识点：
浅层拷贝，对于引用类型，只复制对象的引用地址，而不是重新创建新的对象，因此拷贝出的对象不能独立于原有对象