Java基础
创建第一个程序
打开Eclipse，创建HelloWorld程序
打开Eclipse选择菜单 File --> New --> Java Project新建工程
填写工程名称为TestJava
右键工程名创建类
填写Package包名为com.cz
填写Name类名Test
成功创建包
写输入代码
右键运行
运行结果显示
变量、数据类型
变量
变量的概念：内存根据数据不同类型开辟的这个空间叫做变量
变量名：用于快速找到内存中变量空间位置取得名字
变量的使用
1、声明变量，就是在内存开一个空间
语法：数据类型 变量名;（空格和分号不能少）
2、变量赋值，就是将数据放到开辟的这个空间
语法：变量名 = 变量值;
3、使用变量
比如：System.out.println(变量名);
数据类型
数值型
1、 整型（int）：用于存储整数，整数的类型
byte字节型，short短整型，long长整型
2、 非整型：用于存储小数，小数的类型
双精度浮点型（double）：小数的长度比较长
单精度浮点型（float）：小数的长度短一些
非数值型
1、字符型（char）：用于存储单个字符，都需要使用英文状态的单引号括起来；比如：‘男’、‘女’、‘开’、‘关’
2、字符串型（String）：用于存储一串字符，存储0~n个字符，都需要用英文状态下的双引号括起来；比如：“王者”
类型转换
自动类型转换
1、必须两种类型互相兼容，比如：都是数值类型int和double，double和float
2、转换成的类型一定要比被转换的类型要大，比如：int转换成double，float转换成double
强制类型转换
语法：数据类型 变量名 = (数据类型)变量名;
运算符
1、赋值运算符 =，将右边的值赋给左边
2、算术运算符+、-、、/、%，数学运算一样，先、/、%，后+、-
3、关系运算符（比较运算符）：>、<、>=、<=、==、!=
4、逻辑运算符
boolean类型（布尔类型）：用于比较运算，只有两个值（true和false）
运算符的优先级
1、最高优先级，英文状态下的小括号()
2、最低优先级，赋值运算符=
3、算术运算符>关系运算符>逻辑运算符>赋值运算符
选择结构
if
if-else语句主要是根据if的判断结果，选择不同的分支路径，可以if-else嵌套，也可以单独使用if语句，还可以使用 if-else if-else if-…-else进行嵌套
if基本选择结构
语法：if(要满足的条件){
如果条件为true的时候，进入大括号中
满足条件之后得到的结果，不满足条件不会去执行
}
如果条件为false的时候，绕过大括号执行外面的
条件只能是boolean类型的数据
if-else选择结构
语法：if(要满足的条件){
满足条件得到的结果
}else{
不满足条件的得到的结果
}
多重if选择结构
适用于很多条件分支的情况
语法：if(要满足的条件1){
满足条件1得到的结果
}else if(要满足的条件2){ //默认不满足条件1
满足条件1得到的结果
}else if(要满足的条件n){ //默认不满足条件2
满足条件n得到的结果
}else{ //默认不满足条件n
不满足所有条件得到的结果
}
只要找到一个满足的条件，执行完之后，结束选择结构
嵌套if选择结构
适用于在一个判断的基础再做一次判断的情况
语法：if(要满足的条件1){
满足条件1得到的结果
if(要满足的条件2){
满足条件2得到的结果
}
}else{
不满足条件1得到的结果
}
==只能够比较数值类型，比较字符串是否相等，使用.equals(“要等于哪个字符串”);
比如：sex.equals(“王”)；10 == 10
随机产生
switch
当需要判断的条件比较多时会出现很多的if-else，这种代码的可读性比较差，所以我们可以选择使用switch语句
public static void testSwitch(int color) {
switch (color) {
case 1:
System.out.println("......................");
break;
case 2:
System.out.println("......................");
break;
case 3:
System.out.println("......................");
break;
case 4:
System.out.println("......................");
break;
default:
break;
}
}
跳转语句的使用
break关键字：（通常和if选择结构一起使用）
在switch使用break表示结束switch选择结构去执行选择结构外的代码
在循环中使用break表示结束循环结构去执行循环结构外的代码
continue关键字：（通常和if选择结构一起使用）
continue只能够在循环结构中使用
在循环中使用continue表示结束当前这一次循环，然后开始下一次循环
循环结构
for
语法：for(表达式1;表达式2;表达式3){
循环操作
}
- 表达式1：循环从哪里开始，也就是循环的初始值，比如：int num = 1
- 表达式2：循环的条件，也就是循环到哪里结束，比如：num <100
- 表达式3：计数器，也就是每循环一次，初始值产生怎样的变化，比如：num++
每个表达式之间用分号隔开，每个表达式都可以不写，但是分号不能省略
for循环的执行顺序
①先去执行表达式1，也就是先去找初始值
②第二步去执行表达式2，也就是去找循环条件
③第三步去执行循环操作
④最后才去执行表达式3，也就是最后才实现初始值变化的过程
public static void testFor() {
int[] array = new int[10];
for(int i=0;i<10;i++) {
array[i] = i;
}
for(int j:array) {
System.out.print(j+" ");
}
}
While
while语句是循环语句的另一种方式，当while后面的条件成立时继续循环，当条件不成立是时退出循环，也可以使用do-while嵌套，在do后面首先执行一次循环再到while中进行循环是否继续的检测。
public static void testWhile() {
int[] array = new int[10];
int i = 0;
while(i<array.length) {
array[i] = i;
i++;
}
int j = 0;
do {
System.out.print(array[j]+" ");
j++;
} while (j<array.length);
}
while、do-while和for循环的区别
执行顺序不同
while和for循环：先判断，再执行
do-while循环：先执行，再判断
程序调试
断点调试的步骤：（每次调试后取消掉断点）
- 设置断点：在左侧边栏的位置点击鼠标左键两次，可以生成一个断点
- 进入调试模式：点击右键，选择debug as进入debug调试模式，程序会在设置断点的地方停下来
- 单步执行，也就是一行一行的执行代码，按F6单步跳过执行代码
- 观察变量值的变化
- 找出错误的位置
- 改正错误
- 运行看结果是否正确
二重循环：在一个循环中再使用一个循环结构
循环特点：外层循环循环一次，内层循环循环一遍（也就是从开始到结束循环完）
while循环，do-while循环和for循环之间可以相互嵌套，也就是说while循环可以放while，
do-while和for循环，其他两种一样
二重循环中跳转语句的使用
continue：如果continue在内层循环中，表示结束内层循环的本次循环，开始内层循环的下一次循环，如果在外层循环表示结束外层循环的本次循环，开始外层循环的下一次循环，也就是说，continue在哪一个循环的{}中，就结束哪一个循环的本次循环，开始该循环的下一次循环。
break：如果break在内层循环中，表示结束内层循环的整个循环，开始执行内层循环外面语句，如果在外层循环中表示结束整个循环，也就是说，break在哪个循环中，结束的就是哪个循环的整个循环。
数组
数组的定义
数组的概念：在内存中开辟的一串连续的空间，用来存储相同数据类型的
数组的基本要素
1、标识符（数组名）：数组的名称，用来区分不同的数组
2、数组元素：存放在数组空间中的数据
3、数组下标：对数组中的空间进行编号，区分每个空间，数组下标从0开始，可以通过数组下标找到对应的空间
4、元素类型：数组的数据类型
声明数组：告诉计算机数组是什么类型
语法：数据类型[] 数组名 或者 数据类型 数组名[]
比如：String[] args;int[] nums,数组名的命名方式和变量命名方式一样
分配空间：告诉计算机要开辟一串连续的多长的空间
语法：数组名 = new 数据类型[数组长度];
比如：scores = new int[30];
第一步和第二步可以一起写
数据类型[] 数组名 = new 数据类型[数组长度];
赋值：向开辟好空间里面去存放数据
语法：数组名[数组下标] = 数据;
比如：scores[0] = 60;//表示将数组第一个空间存放了60这个整数scores[1] = 80;
直接声明数组时就进行赋值
语法：数据类型[] 数组名 = new 数据类型[]{数据1，数据2，数据n};
数据类型[] 数组名 = {数据1，数据2，数据n};
注意：如果在声明数组时就直接赋值，那么不要写数组长度
比如：int[] scores = new int[]{60,80,100,50,60,70};
通过循环的方式动态的录入数据
循环从初始0开始，到数组的最大长度结束，每次加1
for(int i = 0;i < 5;i++){
System.out.println("请输入第"+(i+1)+"名学生的成绩：");
scores[i] = input.nextInt();
}
数据的使用：将存放在数组空间中的元素拿出来使用
使用循环的方式将存放在每个空间中数据拿出来使用
for(int i = 0;i < 5;i++){
System.out.println("第"+(i+1)+"名的学生成绩为"+scores[i]);
}
数组名.length表示数组的长度
比如：int[] scores = new int[10];
scores.length = 10;//数组长度为多少，该值就为多少
数组的排序
使用Arrays类，使用Arrays的步骤
1、找到有Arrays的商店，语法：import java.util.Arrays;
2、Arrays是一个公用的工具，不需要够买，只要去使用就可以，语法：Arrays.sort(数组名);
它会将该数组进行一个升序的排列
遍历数组
1.
public class Main {
public static void main(String[] args) {
int[] ns = { 1, 4, 9, 16, 25 };
for (int i=0; i<ns.length; i++) {
int n = ns[i];
System.out.println(n);
}
}
}
public class Main {
public static void main(String[] args) {
int[] ns = { 1, 4, 9, 16, 25 };
for (int n : ns) {
System.out.println(n);
}
}
}
冒泡排序
内置排序
二维数组
二维数组就是数组的数组。
public class Main {
public static void main(String[] args) {
int[][] ns = {
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 }
};
System.out.println(ns.length); //3
System.out.println(ns[1][2]);//7
System.out.println(Arrays.deepToString(ns));//打印二维数组
}
}
面向对象
1.OO:Object Oriented表示面向对象的意思
2.世界由什么组成：水，陆地，草，人，动物，植物，楼房，汽车等等由所有一切真实存在的东西组成，这些真实存在的东西就叫作对象
属性：就是对象所具有特征
方法：就是对象所执行的行为或操作
对象：用来描述真实存在事物的一个实体，由一组属性和方法组成
封装：对象的属性和方法通常封装在一起，共同体现事物的特性，两者不可分割
类：将对象共同的属性和方法抽取出来就是类
类是模子，定义对象所具有的属性和方法
3.类和对象的关系：
类是抽象的，对象是具体的实体
对象是类的一个实体，类是对象的抽象概念
类
定义一个类的步骤
1、新建一个class，给这个class取一个类名，名字和你想要定义的类型一致类名的取名方式，使用帕斯卡命名法，所有单词的首字母大写
2、定义类的属性
3、定义类的方法
使用定义好的类
1、新建一个对象，语法：类名 对象名 = new 类名();
比如：Car car1 = new Car();
2、通过“.”操作符来使用这个对象的属性和方法
方法
无参方法：在方法名()的括号中没有参数的方法
有参方法：在方法名()的括号中有参数的方法
定义有参方法的语法：
语法：访问修饰符 返回值类型 方法名(参数1、参数2、参数3…参数n){
方法体（具体实现方法的过程）
}
.........................................................
定义无参方法的语法：
语法：返回修饰符 返回值类型 方法名(){
//具体实现方法的操作
}
public void TestHello(){
//具体实现方法的操作
System.out.println(“你好”);
}
1、访问修饰符（在哪些地方能够使用这个方法），public公共的，最高级别
2、返回值类型，执行完方法后能够得到什么数据
void，表示没有返回值，也就是没有任何数据返回
如果有数据返回，那么就需要使用return关键字返回一个数据，并且返回的数据类型和返回值的数据类型一致
3、方法名(),方法名表示方法的名字
4、方法体：具体实现方法的操作
5、参数：实际就是声明的一个变量，声明的变量使用“,”隔开在定义方法的时候，方法中的参数只是进行了声明，并没有赋值，这个参数就叫做形式参数，也就是形参；
在调用方法的时候，对方法中参数进行赋值，这个参数就叫作实际参数，也就是实参
调用带参数的方法
- 同一类中调用同一类中的方法，直接方法名()调用
- 不同类中调用不同类中的方法，先new一个对象，再通过对象名.方法名()的方式调用
- 必须和定义方法的参数个数相同，并且数据类型必须一致，顺序也要和定义的位置一致
编写方法步骤
- 先定义方法的访问修饰符，先写没有返回值类型，定义方法名，方法名的命名采用见文识意的方式
- 定义方法体，也就是写具体实现方法的操作
- 判断方法是否有返回值，如果有，添加return关键字返回该数据，并修改返回值类型
方法的调用
1、在同一个类调用同一类中的方法，只需要通过方法名()就可以指直接调用
2、在不同类中调用方法，需要先new一个需要调用方法的类的对象，然后通过对象名.方法名的方式去调用方法调用方法的时候，实际上就是去执行方法体中的代码
常见错误
1、返回值数据类型必须和返回值类型一致
2、不可以返回多个值，也不能写多个返回值类型
3、定义方法不能够相互嵌套
4、程序逻辑代码（顺序、选择、循环结构）只能写在方法体中
构造方法
创建实例的时候，实际上是通过构造方法来初始化实例的。
public class Main {
public static void main(String[] args) {
Person p1 = new Person("Xiao Ming", 15); // 既可以调用带参数的构造方法
Person p2 = new Person(); // 也可以调用无参数构造方法
}
}
class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
}
由于构造方法是如此特殊，所以构造方法的名称就是类名。构造方法的参数没有限制，在方法内部，也可以编写任意语句。但是，和普通方法相比，构造方法没有返回值（也没有void），调用构造方法，必须用new操作符。
方法重载
class Hello {
public void hello() {
System.out.println("Hello, world!");
}
public void hello(String name) {
System.out.println("Hello, " + name + "!");
}
public void hello(String name, int age) {
if (age < 18) {
System.out.println("Hi, " + name + "!");
} else {
System.out.println("Hello, " + name + "!");
}
}
}
这种方法名相同，但各自的参数不同，称为方法重载（Overload）。
注意：方法重载的返回值类型通常都是相同的。
方法重载的目的是，功能类似的方法使用同一名字，更容易记住，因此，调用起来更简单。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
