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

分手后的思念是犯贱 2022-08-06 00:21 99阅读 0赞

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)

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