java基础学习

1.DOS命令
cd\ 返回根目录
cd.. 返回上一级
cd 目录名 进入目录
dir 列出当前目录下的所有文件和文件夹
md 文件夹名 创建文件夹
rd 文件夹名 删除空文件夹
del 文件名.后缀名 删除文件
echo 内容>文件名.后缀名 创建文件并写入内容
cls 清空屏幕
exit 安全退出


2.java发展历程
（1）由sun公司设计，现归Oracle


（2）版本
JavaSE 标准版开发平台
JavaEE 企业级开发平台
JavaME 移动版开发平台
JavaAndroid 安卓版开发平台


3.环境变量的配置
（1）下载、安装
（2）配置
path:JDK安装目录的bin路径;
classpath:.;JDK安装目录的lib路径
（3）检测
在dos命令任何位置都能执行
java javac jar javadoc ...
查看版本
java -version


4.开发体验
（1）创建源文件
新建文本文档，后缀名改为：源文件名.java


（2）编写源文件
使用记事本编写
public class 类名{

public static void main(String[] args){


System.out.print("原样输出不换行");
System.out.println("原样输出之后换行");
}


}


注意： 类名与源文件名一致
单词拼写错误（大小写）
main函数是程序执行的入口
标点符号都是英文


（3）编译源文件
打开DOS命令，切换到源文件所在的目录
编译：javac 源文件名.java


会在同一目录产生一个字节码文件（.class）


（4）运行字节码文件
打开DOS命令，切换到字节码文件所在的目录
运行：java 字节码文件名

会在dos命令输出打印内容
1.标识符
（1）概念：给源文件名、类名、变量名、数组名、方法名、对象等起名字的有效字符序列


（2）规则
a.由字母、数字、下划线、美元符号组成，且首字符不能是数字
b.不能以关键字和保留字作为标识符
c.大小写敏感
（3）关键字和保留字
48个关键字和2个保留字
注意：关键字和保留字都是小写




2.变量和常量
（1）常量：程序在运行时，该容器的数据不能发生变化


（2）变量：程序在运行时，该容器的数据会发生变化
a.变量的声明
语法：数据类型 变量名;


注意：数据类型约束了该变量的类型和取值范围


b.变量的赋值
变量名 = 数据;

注意：等号两边的数据类型保持一致


c.变量的使用
Sytem.out.println(变量名);


使用规则：变量先声明，后赋值，最后进行操作




3.数据类型
（1）8个基本数据类型：在内存占一块空间
byte 整数，1字节，-128——127
short 整数，2字节，-2的15次方——2的15次方-1
int 整数，4字节，-2的31次方——2的31次方-1
long 整数，8字节，-2的63次方——2的63次方-1


float 小数，4字节，-2的31次方——2的31次方-1
double 小数，8字节，-2的63次方——2的63次方-1


char 字符，2字节，有且仅有一个字符，必须用''引起


boolean 逻辑，1bit，true和false


1个byte占8个bit（二进制位）


（2）3个引用数据类型：在内存占两块空间

数组
类：String（字符串），必须用""引起，没有长度限制
接口


4.类型转换
（1）自动类型转换：小类型 会自动提升为 大类型
byte b = 9;
int i = b;

（2）强制类型转换：大类型 必须强制转换为 小类型
double d = 12.3;
int i = (int)d;


注意：大类型的数据，小类型能够容纳，如果出范围，数据会丢失






5.运算符
（1）赋值
= += -= *= /= %=
赋值运算符的优先级相对来说比较低


（2）算术
+ - * / %
++前 后++
--前 后--

前++的运算符等级大于 赋值运算符
后++的运算符等级小于 赋值运算符


如果参加运算都是整数
有long结果为long，无long结果为int


如果参加运算有小数
有double结果为double，无double结果为float


所有的byte、short、char进行运算时，结果会自动提升为int类型


字符串与任何数据类型相加为拼接




（3）比较运算符
> < >= <= == !=
结果为boolean




（4）逻辑运算符
& &&
| ||
^ 相同为false，不同为true
!


（5）三目运算符
数据类型 变量名 = 条件表达式?条件为true执行的语句 :条件为false执行的语句;


（6）位运算符
按位与 &
按位或 |


（7）位移运算符
向左位移 数字<<位数
向右位移 >>
流程控制语句
1.程序运行的三种结构
（1）顺序结构
（2）选择结构
（3）循环结构
（4）流程跳转语句


2.选择结构
（1）if单分支
if(条件表达式){
//条件表达式为true，执行的语句或语句组
}


（2）if双分支
if(条件表达式){
//条件表达式为true，执行的语句或语句组
}else{
//条件表达式为false，执行的语句或语句组
}


（3）if多分支
if(条件表达式1){
//条件表达式1为true，执行的语句或语句组
}else if(条件表达式2){
//条件表达式2为true，执行的语句或语句组
}else if(条件表达式3){
//条件表达式3为true，执行的语句或语句组
}
...
else{
//上面都为false，执行的语句块
}


（4）switch开关
switch(表达式){
case 常量1:
//常量1等于表达式，执行的语句块
[break;]
case 常量2:
//常量2等于表达式执行的语句
[break;]
...
default:
//上面常量都不相等表达式，执行的语句组
}
表达式：byte、short、int、charJDK1.7开始支持String




3.循环结构
（1）for循环
for(初始化表达式;条件表达式;迭代语句){
//循环体
}


（2）while循环


while(条件表达式){
//循环体
}




（3）do . while


do{
//循环体
}while(条件表达式);


注意：至少会执行一次




4.流程跳转语句
（1）break：在循环中，结束循环体；在switch，结束条件判断
（2）continue：只能作用在循环体，结束循环体的本次循环，而进入下次循环


1.数组
（1）概念：用来存储具有相同数据类型的集合
（2）特点：
a.数组是一种引用数据类型
b.使用数组声明的变量，只能保存数组对象
c.数组对象的内部划分为多个元素，每个元素只能存一条数据
d.数组的长度一旦创建，不可改变
e.数组可以存放任何数据类型


2.数组的使用
（1）数组变量的声明
数据类型[] 数组名;
数据类型 数组名[];




（2）数组对象的创建
数组名 = new 数据类型[长度];//长度是元素的个数


（3）数组元素的赋值
元素：数组名[下标]
数组名[下标] = 数据;


注意：数组的最大下标为：长度-1


（4）数组元素的使用
System.out.println(数组名[下标]);


（5）元素的遍历
数组的长度：数组名.length
for(int i = 0 ; i < 数组名.length ; i ++ ){
System.out.println(数组名[i]);
}




3.缺省值
数据类型 缺省值
整数 0
小数 0.0
字符 空格或方框
布尔 false
引用 null


4.声明的方式
（1）数据类型[] 数组名 = new 数据类型[长度];


（2）数据类型[] 数组名 = {数据1,数据2,...,数据n};//不能拆开


（3）数据类型[] 数组名 = new 数据类型[]{数据1,数据2,...,数据n};




5.排序
（1）冒泡排序
（2）选择排序


6.多维数组
（1）一维数组：数组的元素是一条数据，不可分割


（2）二维数组：数组的元素又是一个数组对象


（3）多维数组：多维数组的本质就是一维数组



7.二维数组
（1）变量声明
数据类型[][] 数组名;


（2）对象创建
数组名 = new 数据类型[外长度][内长度];


（3）元素赋值
数组名[外下标][内下标] = 数据;


（4）元素遍历
for(int i = 0 ; i < 数组名.length ; i ++ ){
for(int j = 0 ; j < 数组名[i].length ;  j ++){
System.out.println(数组名[i][j]);
}
}


面向对象
基础：类、对象、对象的使用、包、重载、修饰符
特点：封装、继承、多态、抽象
扩展：抽象类、接口、内部类

1.生活中的面向对象
（1）面向对象
把所有事物都理解为对象，我们站在java开发的角度进行思考问题


（2）对象
客观存在能够相互区分的个体


（3）类
具有相同属性和行为的对象的群体或抽象


（4）类与对象的联系
类是对象的抽象或概括
对象的类的实例化


类作为java设计的基本单元




2.类的定义及使用
（1）java中类的定义
[修饰符] class 类名{
//成员变量--属性--字段
[修饰符] 数据类型 变量名 [= 数据];


//构造器--构造方法--构造函数
[修饰符] 构造器名([参数类型 变量名,...]){//主要功能：创建对象

}


//成员方法--行为--函数
[修饰符] 返回值类型 方法名([参数类型 变量名,...]){
//该方法完成的功能
}


}


注意：构造器名与类名一致


（2）对象的使用
a.类变量的声明：类名可以作为一种数据类型，使用类声明的变量只能保存该类的对象
类名 对象名;


b.类对象的创建
对象名 = new 构造器名();


c.对象属性的赋值：属性:对象名.属性名
对象名.属性名 = 数据;


d.对象属性和方法的使用
System.out.println(对象名.属性名);
对象名.方法名();


3.成员变量和局部变量的区别
（1）定义在类中方法体之外；定义在方法体中或者参数
（2）有缺省值； 无缺省值
（3）可以使用修饰符 只能使用final修饰
（4）作用域：整个类中 只能作用在当前方法体


4.参数
（1）本质：特殊的局部变量
（2）作用：在调用方法时，动态的通过实参传给形参


5.重载（Overload）
方法的重载


（1）概念：在一个类中可以定义多个方法名相同的
（2）规则：
a.同一个类中
b.方法名相同
c.参数不同：数据类型、顺序、个数


构造器的重载



6.this关键字
（1）当前对象
一个类中可以定义局部变量和成员变量同名，在方法中隐藏了成员变量
想调用成员变量：this.成员变量名;




（2）当前类的其他构造器
一个构造器可以调用另一个构造器
在构造器的第一条语句：this(数据,...);


注意：只会创建一个对象，借助其他构造器完成初始化




7.修饰符
（1）访问修饰符
public
protected
缺省
private


（2）非访问修饰符
static
类成员和实例成员区别
类成员该类的每个对象共同拥有的；实例成员该类的每个对象都有的
类成员可以通过类名直接调用，实例成员也可以创建对象调用；必须通过创建对象来调用
类方法只能访问类成员； 实例方法可以访问所有成员


final
abstract