本帖最后由 koi 于 2018-3-27 15:06 编辑
JavaEE11期基础班学习总结
一:Java概述
发展历史
由詹姆斯高思林创立,1995年诞生于sun公司
特点
开源:mac,windows,linux平台
跨平台:原理:每个平台都有对应的jvm虚拟机,一次编写到处运行.
JVM,jRE,JDK的概述
JDK:java开发工具,带有JRE以及开发工具:Javac.exe,java.exe等
JRE:java运行环境,可以运行开发好的java程序,带有jvm和核心类库
JVM:运行java程序虚拟机
常用dos命令
d:回车 盘符+: 进入该盘根目录
dir 显示当前目录下的文件与文件
cd 目录 转到该目录
cd.. 回到上级目录
cd\ 回到盘根目录
cls 清屏
md 在当前目录下创建文件夹
rd 在当前目录下移除文件夹
二:常量,变量
常量: 程序运行过程中值不会发生改变的量
分为字符串常量,整型常量,浮点常量,字符常量,布尔常量,空常量
字符串常量: String ""
整型常量:byte short int long
浮点常量:float long
字符常量:char ''
布尔常量:boolean
空常量:null
变量
程序运行过程中,值可以在一定范围内发生改变的量
三:数据类型
java是强数据类型的编程语言→好处:省空间内存
分为:
基本数据类型:
数值类型
整型
byte 1byte
short 2byte
int 4byte
long 8byte
浮点
float 4byte
double 8byte
字符类型
char 2byte
布尔类型
true,false 1byte
隐式转换
小的数据与大的数据做运算时自动提升为大的数据
例如:byte + int = int
byte a = 2;
byte b = 2;
short c = a + b;会报错,右边的运算会提升为int,所以会损失精度
强制转换
大的数据类型转会小的数据类型
例如: int a = 3; int b = 3; short c = (short)(a + b);
四:选择,循环控制语句
选择流程控制
主要分为两种: if 和 switch
if:
if第一种格式:
if (判断表达式) {
语句体;
}
关系表达式为true时执行
if第二种格式:
if (判断表达式) {
语句体;
} else {
语句体;
}
if第三种格式:
if (判断表达式) {
语句体;
} else if {
语句体;
} else if {
...
} else {
}
注:从上到下顺序执行,当第一条条件满足时,流程控制语句结束,其他判断语句不执行;
switch:
标准格式为:
switch (表达式) { // 表达式只接受 byte,short,int,char,枚举,String类型的数据
case 值一:
语句体;
break;
case 值2:
语句体;
break;
case 值3:
语句体;
break;
...
default: //在其他case都不满足的情况下执行;
语句体;
break;
}
注:switch语句遇break 或 } 结束;
如果case后面不写break的话,有可能出现case穿透的情况
------------------------------------------------------------------------------------------
循环流程控制语句
主要分为: for循环,while循环,do while 循环
for 循环:
格式为:
for(初始化语句;循环判断语句;控制条件语句) {
循环体;
}
执行顺序为: 初始化语句 -- 循环判断语句 -- 循环体 --控制条件语句 -- 循环判断语句 -- 循环体 --.....
for循环的变形格式：
int x=1;
for(; x<=10; x++){
......
}
int z=1;
for( ;z<=10;){
......
z++;
}
while循环:
格式为:
初始化表达式
while(循环判断条件语句) {
循环体;
控制条件语句;
}
执行顺序为:与for循环一致
结束循环:当循环判断条件为false时
do while循环:
格式为:
初始化语句;
do {
循环体语句;
控制条件语句;
} while (循环判断语句);
执行顺序:
初始化语句 -- 循环体 -- 控制条件语句 -- 循环判断语句 -- 循环体 -- 控制条件语句
结束循环: 循环判断表达式为false时
三种循环的区别
for循环的控制条件变量通常定义在方法中,所以循环执行完后变量会消失,不可方位到,
但是可以节省内存.
while与dowhile循环的控制条件变量通常定义再方法外,循环结束后,变量还可以使用;
dowhile循环至少会执行一次循环体.
可根据需要选择循环;
死循环:
while (true) {
}
for(;true;) {
}
do {
}while(true);
之类的为死循环.
--------------------------------------------------------------
控制循环语句: break,continue;
break:
跳出单层循环
用在switch和循环语句中
作用是终止switch和退出当前循环循;
continue:
跳出单层循环,退出本次循环
用在循环语句中;
作用是结束当前循环进入下一循环;
五:随机数
Random:生成随机数方法
1,导入包
import java.util.Random
2,创建对象
Random r = new Random();
3,定义接收变量
int n = r.nextInt(数字number); //数字随机生成范围 [0,number)
例: int n = r.nextInt(100);//随机生成0-99的数
r.nextInt(41) + 25; //随机生成 25-65的数
六:数组
一维数组
定义:
1,数据类型[] arr;(推荐)
2,数据类型 arr[];
初始化:
动态初始化: 数据类型[] arr = new 数据类型[4];
静态初始化: 数据类型 arr[] = new 数据类型{ 1 , 2 , 3 };
简写形式: arr = { 1 , 2 , 3 };
注意简体形式不能写成两行,否则会报错,即:
int[] arr;
arr = { 1 , 2 , 3 }
变量arr实际是存储着数组对象在堆的地址,如:[I@179935d
一个[代表一维数组
使用:
arr :i为在数组长度范围内的索引,arr表示取数组中第i个元素(索引从0开始)
遍历:
利用循环语句遍历;
for (int i = 0; i < arr.length; i++) { //arr.length代表数组的长度
System.out.println(arr);
}
求数组最大值:
先定义一个输出最大值变量 max,取数组第一个数为参照物;
然后遍历数组一次比较,得出最大值;
代码例:
int[] arr = {1,2,3,4,5,2};
int max = arr[0]; //不能先定义max为0,如果数组里的元素都为负数,
则0将成为最大值;
for (int i = 1; i < arr.length; i++) {
if (max < arr) {
max = arr;
}
}
二维数组
定义:
1,数据类型[][] 变量名;(推荐)
2,数据类型[] 变量名[];
3,数据类型 变量名[][];
初始化:
1,动态初始化:例:int[][] arr = new int[3][4];
//定义了一个有3个一维数组, 每个一维数组含有4个变量的二维数组;
2,静态初始化:int[][] arr = {{1},{2,3},{4,5,6}}
//静态初始化,一维数组的元素个数可以不相等;
使用:
数组名[j] : i为一维数组的索引,j为该一维数组中元素的索引;
遍历:
for(int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length; j++) {
a[j];
}
}
七:Jva内存分配
栈(存储的是局部变量)
堆(存储的是new出来的对象)
方法区(存储class文件)
本地方法区(和系统相关)
寄存器(给cpu使用)
八:方法
格式:
修饰符 返回值类型 方法名 (参数类型 参数1,参数类型 参数2,...) {
方法体;
返回语句;
}
public static int sum(int a, int b) {
int c = a + b;
return c;
}
无返回值类型时 返回值类型出填 void 并且可以省略return返回语句;
硬要写的话就写 return;
方法的重载:
参数名相同,参数列表不同,与返回值无关
例:
public static int sum(int a, int b) {
int c = a + b;
return c;
}
public static int sum(int a, int b, int c) {
int c = a + b + c;
return c;
}
方法对参数的影响:
当传入的实际参数为基本数据类型时,形式参数的改变对实际参数没有影响;
当传入的实际参数为引用类型时,形式参数改变则实际参数改变;
这是因为,基本数据类型的参数传递是以相同的数据赋值给形式变量.
但是引用类型的参数传递,实际上只传递了数据的地址值.
九:基础算法
不死神兔问题描述:
有一对兔子,三个月后每个月就生一对兔子,生下的小兔子,三个月后也是每个月生一对兔子,
请问,20个月后有多少对兔子.
找规律:
第一个月:1
第二个月:1
第三个月:2
第四个月:3
第五个月:5
第六个月:8
...
(规律:每个月的兔子数量为前两个月的数量之和)
代码1:(伪代码)
int a = 1;
int b = 1;
int sum = 0;
for(int i = 2; i < 20; i++) {
sum = a + b;
a = b;
b = sum;
}
int a = 0;
int b = 1;
for (int i = 0; i < 20; i++) {
a = a + b;
b = a - b;
}
用数组解决:
int[] arr = new int[20];
arr[0] = 1;
arr[1] = 1;
for (i = 2;i < 20; i++) {
arr = arr[i-1] + arr[i-2];
}
答案为6765对
数组的反转:
第一个数与最后一个数交换
第二个数与倒数第二个数交换
...
代码:
//只用循环一半即可
for(int i = 0; i < arr.length / 2; i++) {
int temp = arr;
arr = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
十:面向对象
面向对象概述:
面向对象是基于面向过程的;
对于任何事物都可以用属性和方法来描述
我们将拥有相似属性和方法的事物描述为一类事物
在java中用class类来表示
在定义class时用成员变量来代表事物的属性,
成员方法来代表事物的行为
例如:
class Student{
String name;
ing age;
public void study(){
System.out.println("study");
}
}
对象时类的具体实现;
比如学生作为一个类,那么作为学生的你就是一个对象
java中对象的创建格式为:
类名 对象名 = new 类名();
对象创建后是存储在堆内存中,赋予对象名的是它的存储地址.
使用类:
例:
class StudentTest {
public static void main(String[] args) {
Student s = new Student();
s.name = "jack";
s.age = 18;
s.study();
}
}
通过类对象的创建,用s.name/study(),这种 类名.属性/方法的形式可以对对象的属性
进行更改,和调用对象的方法
private:
虽然可以直接用s.age这种形式直接对对象的成员变量进行更改,但是类似s.age= -18等
不符合常理的更改则得不到有效预防.为了增加数据的安全性,用private修饰的成员变量
只能在本类中访问,其他类中不能访问.
但是通过定义setXXX,getXxx方法可以对变量进行间接的更改或访问,这样做的好处是在
方法中可以加入保证
数据安全的代码.
例:
class Student{
String name;
ing age;
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(int a) {
if (a > 0 || a < 200) {
System.out.println("您输入的年龄有误");
//例如通过类似这种数据安全保护措施
} else {
age = a;
}
}
public int getAge() {
return age;
}
public void study(){
System.out.println("study");
}
}
封装
private实际上是封装的一类,通过private等权限设置,将不需要对外显示的内容
隐藏起来,提高类代码的安全性,与稳定性,和复用性.
this
为了使得定义set,get等方法时,做到见名之意,Java定义了this关键字
例:
class Student{
String name;
ing age;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
this代表当前类的当前对象,简单的说就是谁调用我,我就是谁.
就近原则:
事实上,在方法内,使用变量时,哪个变量最近就用哪个.如果方法里没有该变量, 才会去方法外的类里去找.
public void setName(String name) {
this.name = name;
}
//如果不用this的话,两个name都是形式参数的name,
变成自己给自己赋值,毫无意义
成员变量与局部变量的区别
1,位置不同
成员变量定义在类中,方法外
局部变量定义在方法上或方法中
2,存储位置不同
成员变量存在堆内存中
局部变量存储在栈内存中
3,生命周期不同
成员变量随着对象的创建而创建,随着对象的消失而消失
局部变量随着方法的导入而创建,随着方法的结束而消失
4,初始化值不同
成员变量有默认初始化值
局部变量没有默认初始化值,必须要赋值后才可以使用;
构造方法:
目的:在对象创建时初始化成员变量
1,在定义类时如果没有定义构造方法,则系统给出默认无参构造方法.
2,如果定义类时给出了构造方法,则系统不提供默认无参构造方法
3,构造方法可以重载
定义格式: public 类名(参数列表){
}
Student s = new Student();
//我们通常说的创建对象,实际上就是调用的类的构造方法.
例:
class Student{
String name;
ing age;
public Student() {
//即使定义了有参构造方法,以防万一最好还是定义上无参构造方法
}
public Student(String name) {
this.name = name;
}
public Student(int age) {
this.age = age;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void study(){
System.out.println("study");
}
}
|
|
收藏
淘帖
踩
