Java-核心编程实验课笔记（一）
一；Java特性和优势
1；简单性
2；面向对象
3；可移植性
4；高性能
5；分布式
6；动态性
7；多线程
8；安全性
9；健壮性
二；Java程序运行机制
1；编译型
2；解释型
3；程序运行机制
课堂代码
package day01;
public class Demo02 {
public static void main(String args[]){
/**
* 变量命名
* 语法：变量类型 变量名字 赋值符号 值；
*/
int age; // 变量声明，不赋值
age=32;// 声明变量之后赋值
String name="大锤"; //声明变量，赋值
// 修改变量值(重新赋值)
age=56;
name="张三";
// int num;
// num="北京中关村";
// int 2num; // 非法命名
int n1, n2, n3, n4;// 批量命名(不推荐使用)
n1=2;
n2=3;
n3=4;
n4=5;
n1=n2=n3=n4=56;
int num=3,num2=4;
}
}
package day01;
public class Demo03 {
/**
* 全局变量；
* 定义在方法（函数）和代码块之间的变量
* 局部变量；
* 定义在方法或者代码块之间的变量
*/
//定义全局变量
int age;//全局变量
String name="大锤";
//静态变量
static int number;
static double price=1399.99;
public static void main(String[]args){
//定义全局变量
int age;
if (true){
String location;
}
//System.out.println(location);
}
}
三；
Java常量（静态常量，成员常量，局部常量）
1；常量值
整形常量值有（十进制，八进制，十六进制）3种形式
转义字符
\r 回车
\n 换行
\b 退格
\t 横向跳格
注；当常量被设定后，一般情况下不允许再被更改。
四；Java数据类型
注；Java是一种强制类型的语言，所以的变量都必须先明确定义其数据类型，然后才能使用。
注释代码；
1；package com.zpark.day02; public class Demo02 { public static void main(String[] args) { /** * Java中的数据类型： * 1、基本数据类型（八种） * byte（字节型）、short（短整型）、int（整形）、long（长整型）、float（单精度浮点型）、double（双精度浮点型） * char（字符型）、boolean（布尔型） * 2、引用数据类型 * 除了基本数据类型，其他全部是引用数类型，如：String、数组等 */ // 字节型 byte by = 127; // System.out.println((byte) (by + 1)); // 短整型 short sh = 56; // 整形 int num = 78946; // 长整型，注意: 需要早长整型末尾添加L或者l long number = 56L;
// 单精度浮点型, 注意: 需要早长整型末尾添加F或者f float fl = 3.14F; float fl1 = 3.1415888888879874243246564564561129f; // 精度丢失 System.out.println(fl1);
// 双精度浮点型,java中小数默认是double类型 double db = 3.14159;
// 字符型, 字符型的值使用单引号引起来，当值为整形时不需要单引号 char ch1 = 3; char ch2 = 'a'; char ch3 = 97; System.out.println(ch1); System.out.println(ch3);
// 布尔值类型，注意：Java中布尔值类型只有true和false两个值 boolean bool1 = true; boolean bool2 = false;
} }
Java-核心编程实验笔记（二）
一、数据类型转换
1；数据类型的转换是在所赋值的数值类型和被变量接收的数据类型不一致时发生的，它需要从一种数据类型转换成另一种数据类型。数据类型的转换可以分为隐式转换（自动类型转换）和显式转换（强制类型转换）两种。
（1）；隐式转换（自动类型转换）：小类型数据转换为大类型数据
满足条件：a、两种数据类型彼此兼容
b、目标类型的取值范围大于源数据类型（低级类型数据 转换成高级类型数据
3、在运算过程中，由于不同的数据类型会转换成同一种数据类型， 所以整型、浮点型以及字符型都可以参与混合运算。自动转换的规则是从低级类型数据转换成高级类型数据。
转换规则如下：
数值型数据的转换：byte→short→int→long→float→double。
字符型转换为整型：char→int。
以上数据类型的转换遵循从左到右的转换顺序，最终转换成表达式中 表示范围最大的变量的数据类型。
2、显示转换（强制类型转换）大类型数据转换为小类型数据需要强制转换
语法:小类型变量名 = (需要转换的类型 (小类型)) 大类型;
注意：大类型数据转换为小类型数据有可能会造成精度丢失和溢出
short类型和char类型在转换时都需要强制转换
例如：byte b1 = 25;
short s1 = b1;
注意： char 类型比较特殊，char 自动转换成 int、long、float 和 double，但 byte 和 short 不能自动转换为 char，而且 char 也不能自动转换为 byte 或 short。
2、显式转换（强制类型转换）
（1） 大类型数据转为小类型数据时需要强制转换
（2） 小类型 变量名 = (需要转换的类型) 大类型;
注意：大类型数据转为小类型数据有可能会造成数据进度丢失和溢出、
例如：short s2 = 654;
byte b2 = (byte) s2;
注： short类型与char类互相转化需要强制转换
例如：short a1 = 56;
char a2 = (char) a1;
String str1="Hello";
int num1=(int)str1; //不能强转;
String str1=(String)num1; //不能强转;
注意：两种数据类型彼此兼容，否则不能互相转换
基本数据类型不能与引用数据类型转换
注意：+号可以用作算术符号，也可以做字符串拼接//这样就可以相加。
任何数据类型与字符串做+运算都会变为字符串
b1+num将数据类型统一之后在运算(往大类型数据统一)
Java运算符: 最基本的运算符包括算术运算符、赋值运算符、逻辑运算符和关系运算符等
代码实例
| package com.zpark.day03; public class Demo03 { public static void main(String[] args) { byte b1 = 12; int num = 13; byte b2; // 将b1+num的结果赋值给b2 // b1 + num 将数据类型统一之后再运算（往大类型数据统一） b2 = (byte) (b1 + num); double d1 = 3.14159; char ch1; |
（8.30）
一、一元运算符
/**
* 一元运算符：
* -：取反
* ++：自增
* --：自减
*/
a ++ 和 ++ a 的区别
int a1 = 98;
int a2;
a2 = a1 ++;
//先将 a1 的值赋给 a2, a1 再自增 1
a2 = ++ a1;
//先将 a1 的值自增 1 ，再赋值给a2;
a -- 和 -- a 同理
二、二元运算符
/**
* Java 语言中算术运算符的功能是进行算术运算，
* 除了经常使用的加（+）、减（-）、乘（`*`）和除（\）外，
* 还有取模运算（％）。加（+）、减（-）、乘（`*`）、除（\）
* 和我们平常接触的数学运算具有相同的含义
*/
注意： Java 语言算术运算符的优先级是先乘除后加减。
如果在一个表达式中的多个算术运算符的优先级别相同，例如“a-b+c”，此时将按照运算符的结合方向决定顺序。算术运算符的结合方向都是“从左至右”，即先左后右。
三、 java中赋值运算符：
* =：赋值符号
* +=：如， num += 2; -----> 本质：num = num + 2;
* -=: 如， num -= 2; -----> 本质：num = num - 2;
* *=: 如， num *= 2; -----> 本质：num = num * 2;
* /=: 如， num /= 2; -----> 本质：num = num / 2;
* %=: 如， num %= 2; -----> 本质：num = num % 2;
四、java中逻辑运算符：
/**
* java中逻辑运算符：
* 与、或、非
* &&（短路与）：如：a && b, 如果ab全部为true则结果为true，否则为false
* ||（短路或）：如：a || b, a或者b有一个为true，或者ab均为true，则为true，否则为false
* ！：a为true，则结果为false，a为false，则结果为true
*/
/**
* && 与 & 区别：如果 a 为 false，则不计算 b（因为不论 b 为何值，结果都为 false）
* || 与 | 区别：如果 a 为 true，则不计算 b（因为不论 b 为何值，结果都为 true）
*/
逻辑运算符的优先级：
！运算级别最高，&& 运算高于 || 运算。！运算符的优先级高于算术运算符，而 && 和 || 运算则低于关系运算符。
课堂作业实例
| package com.zpark.day05; import java.util.Scanner; public class Demo04 { public static void main(String[] args) { /** * 1、定义String类型变量 name * 2、定义int类型变量 age * 3、定义double类型变量 height * 4、定义boolean类型变量 flag * 5、创建Scanner扫描器对象 * 6、提示用户输入用户的名字、年龄、身高、flag * 7、获取用户输入的名字、年龄、身高、flag，并且给相应的变量赋值 * 8、将获取的数据打印到控制台 * 如：name = “张三”， age = 25， height = 199.5， flag = true */ String name; int age; double height; boolean flag; // 创建扫描器对象 Scanner scan = new Scanner(System.in); System.out.println("请输入您的名字："); name = scan.next(); System.out.println("请输入您的年龄："); age = scan.nextInt(); System.out.println("请输入您的身高："); height = scan.nextDouble(); System.out.println("请输入状态："); flag = scan.nextBoolean(); System.out.println("name = " + name + ", age = " + age + ", height = " + height + ", flag = " + flag); } } |
（8.31）
一、.关系运算符
关系运算符（relational operators）也可以称为“比较运算符”，用于用来比较判断两个变量或常量的大小。关系运算符是二元运算符，运算结果是 boolean 型。当运算符对应的关系成立时，运算结果是 true，否则是 false。
注意点如下所示：
1、基本类型的变量、值不能和引用类型的变量、值使用 == 进行比较；boolean 类型的变量、值不能与其他任意类型的变量、值使用 == 进行比较；如果两个引用类型之间没有父子继承关系，那么它们的变量也不能使用 == 进行比较。
2、== 和 != 可以应用于基本数据类型和引用类型。当用于引用类型比较时，比较的是两个引用是否指向同一个对象，但当时实际开发过程多数情况下，只是比较对象的内容是否相当，不需要比较是否为同一个对象。
实例
| public class Demo02 { public static void main(String[] args) { /** * 当引用数据类型使用==和！=做比较运算时的区别： * */ String s1 = "Hello"; String s2 = "Hello"; String s3 = new String("Hello"); System.out.println(s1 == s2); System.out.println(s1 == s3); /** * s1.equals(s3)：比较s1与s3的内容是否相同 */ System.out.println(s1.equals(s3)); |
关系运算符的优先级为：>、<、>=、<= 具有相同的优先级，并且高于具有相同优先级的 !=、==。关系运算符的优先级高于赋值运算符而低于算术运算符，结合方向是自左向右。
3、equals(obj)方法和 == 的区别：
* equals方法比较的是两个对象的内容是否相等
* == 比较的是两个对象再内存中存放的地址是否为同一个
*/
二、Scanner的基本使用
| public class Demo03 { public static void main(String[] args) { /** * java扫描器：用户从控制台输入数据，后台Java程序接收 * */ // 创建扫描器对象 Scanner scan = new Scanner(System.in); //System.out.println("请输入您的年龄："); // 使用scan.nextInt()方法获取用户输入的年龄（整数） //int age = scan.nextInt(); //System.out.println(age); // 获取用户输入的小数 // System.out.println("请输入商品价格："); //System.out.println(scan.nextDouble()); // 获取用户输入的字符串 //System.out.println("请输入您的名字："); System.out.println("请您写一句诗："); // System.out.println(scan.next()); System.out.println(scan.nextLine()); /** * next()与nextLine()方法的区别： * 1、当遇到空格或者回车的时候 next()方法停止读取 * 2、当遇到回车的时候 nextLine()方法停止读取，读取整行数据 */ } } |
三、位运算符
位运算符主要用来对操作数二进制的位进行运算。按位运算表示按每个二进制位（bit）进行计算，其操作数和运算结果都是整型值。
- 位逻辑运算符
位逻辑运算符包含 4 个：&（与）、|（或）、~（非）和 ^（异或）。除了 ~（即位取反）为单目运算符外，其余都为双目运算符。下表中列出了它们的基本用法。
| 运算符 |
含义 |
实例 |
结果 |
| & |
按位进行与运算（AND） |
4 & 5 |
4 |
| | |
按位进行或运算（OR） |
4 | 5 |
5 |
| ^ |
按位进行异或运算（XOR） |
4 ^ 5 |
1 |
| ~ |
按位进行取反运算（NOT） |
~ 4 |
-5 |
2、位与运算符
位与运算符为&，其运算规则是：参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位同时为 1，那么计算结果才为 1，否则为 0。因此，任何数与 0 进行按位与运算，其结果都为 0。
3、位或运算符
其运算规则是：参与运算的数字，低位对齐，高位不足的补零。如果对应的二进制位只要有一个为 1，那么结果就为 1；如果对应的二进制位都为 0，结果才为 0。
4、位异或运算符
位异或运算符为^，其运算规则是：参与运算的数字，低位对齐，高位不足的补零，如果对应的二进制位相同（同时为 0 或同时为 1）时，结果为 0；如果对应的二进制位不相同，结果则为 1。
位取反运算符
位取反运算符为~，其运算规则是：只对一个操作数进行运算，将操作数二进制中的 1 改为 0，0 改为 1。
Java核心编程实验笔记（三）
1、语句编写方式：在 Java 中，语句是最小的组成单位，每个语句必须使用分号作为结束符。
2、语句表达式：
在很多的高级语言中，有专门的赋值语句。而在 Java 中将赋值作为一个运算符，因此只有赋值表达式。在赋值表达式后面添加分号就成了独立的语句。
3、复合语句：复合语句又称为语句块，是很多个语句的组合，从而可以将多个语句看作单个语句。
一、if_else语句
选择结构（也叫分支结构）解决了顺序结构不能判断的缺点，可以根据一个条件判断执行哪些语句块。选择结构适合于带有逻辑或关系比较等条件判断的计算。例如，判断是否到下班时间，判断两个数的大小等。
if 语句是使用最多的条件分支结构，它属于选择语句，也可以称为条件语句。if 选择结构是根据条件判断之后再做处理的一种语法结构。默认情况下，if 语句控制着下方紧跟的一条语句的执行。不过，通过语句块，if 语句可以控制多个语句。if 语句的最简语法格式如下，表示“如果满足某种条件，就进行某种处理”。
课堂实例：
| public class Demo01 {
|
if 语句的主要功能：是给程序提供一个分支。然而，有时候程序中仅仅多一个分支是远远不够的，甚至有时候程序的分支会很复杂，这就需要使用多分支的 if…else if 语句。
通常表现为“如果满足某种条件，就进行某种处理，否则如果满足另一种条件才执行另一种处理……，这些条件都不满足则执行最后一种条件”。if…else ifif (表达式) {
语句块1;
} else {
语句块2;
} 多分支语句的语法格式如下所示：
if(表达式1) {
语句块1;
} else if(表达式2) {
语句块2;
...
} else if(表达式n) {
语句块n;
} else {
语句块n+1;
}
课堂实例：
/**
*单分支结构
*if（）{
*}
*/
/**
*双分支结构
*if语句：
*If（条件表达式）{
*//条件为true
*//代码块
*}else{
*条件语句为false执行
*}
/**
*多分支结构
*if（）{
*}else if (){
*} else if(){
*}…….{
/***
*f嵌套
* if(boolean){
* if(boolean){
* ....
* }
* }else{
* if(boolean){
* ....
* }
*//最后的else语句可要可不要
案例：QQ登录功能，登录流程：1、用户输入用户名，2、用户输入密码，3、点击登录按钮
*/
| // 第一种情况：先判断用户名，然后判断密码 |
三目运算符
Java 提供了一个特别的三元运算符（也叫三目运算符）。三元运算符的符号表示为“?:”，使用该运算符时需要有三个操作数，因此称其为三目运算符。使用条件运算符的一般语法结构为：result = <expression> ? <statement1> : <statement3>;其中，expression 是一个布尔表达式。当 expression 为真时，执行 statement1， 否则就执行 statement3。此三元运算符要求返回一个结果，因此要实现简单的二分支程序，即可使用该条件运算符。
3.2、在使用条件运算符时，还应该注意优先级问题，在编译时会出现语法错误，因为条件运算符优先于赋值运算符。
四、switch case语句
switch 语句是 Java 的多路分支语句。它提供了一种基于一个表达式的值来使程序执行不同部分的简单方法。因此，它提供了一个比一系列 if-else-if 语句更好的选择。
| switch(表达式) { case 值1: 语句块1; break; case 值2: 语句块2; break; … case 值n: 语句块n; break; default: 语句块n+1; break; } |
其中，switch、case、default、break 都是 Java 的关键字。
Switch:表示“开关”，这个开关就是 switch 关键字后面小括号里的值，小括号里要放一个整型变量或字符型变量。表达式必须为 byte，short，int，char类型。Java7 增强了 switch 语句的功能，允许 switch 语句的控制表达式是 java.lang.String 类型的变量或表达式。只能是 java.lang.String 类型，不能是 StringBuffer 或 StringBuilder 这两种字符串的类型。
Case: 表示“情况，情形”，case 标签可以是：
1、类型为 char、byte、 short 或 int 的常量表达式。
2、枚举常量。
3、从 Java SE 7 开始， case 标签还可以是字符串字面量。
default: 表示“默认”，即其他情况都不满足。default 后要紧跟冒号，default 块和 case 块的先后顺序可以变动，不会影响程序执行结果。通常，default 块放在末尾，也可以省略不写。
**注意：**重复的 case 值是不允许的。
break：表示“停止”，即跳出当前结构。
如果在 case 分支语句的末尾没有 break 语句，有可能触发多个 case 分支。那么就会接着执行下一个 case 分支语句。这种情况相当危险，常常会引发错误。为此，我们在程序中从不使用 switch 语句。
switch 语句的执行过程如下：表达式的值与每个 case 语句中的常量作比较。如果发现了一个与之相匹配的，则执行该 case 语句后的代码。如果没有一个 case 常量与表达式的值相匹配，则执行 default 语句。当然，default 语句是可选的。如果没有相匹配的 case 语句，也没有 default 语句，则什么也不执行。
一、嵌套语句（switch）
可以将一个 switch 语句作为一个外部 switch 语句的语句序列的一部分，这称为嵌套 switch 语句。因为一个 switch 语句定义了自己的块，外部 switch 语句和内部 switch 语句的 case 常量不会产生冲突。例如，下面的程序段是完全正确的：
switch特点：
1、switch 语句不同于 if 语句的是 switch 语句仅能测试相等的情况，而 if 语句可计算任何类型的布尔表达式。也就是 switch 语 句只能寻找 case 常量间某个值与表达式的值相匹配。
2、在同一个 switch 语句中没有两个相同的 case 常量。当然，外部 switch 语句中的 case 常量可以和内部 switch 语句中的 case 常量相同。
3、switch 语句通常比一系列嵌套 if 语句更有效。
二、If语句何switch语句的区别
1. 从使用效率上区分
从使用效率上区分，在对同一个变量的不同值作条件判断时，既可以使用 switch 语句，也可以使用 if 语句。使用 switch 语句的效率更高一些，尤其是判断的分支越多，越明显。
2. 从实用性上区分
从语句的实用性角度区分，switch 语句不如 if 条件语句，if 语句是应用最广泛和最实用的语句。
3. 何时使用 if 语句和 switch 语句
在程序开发的过程中，何时使用 if 语句和 switch 语句，需要根据实际情况而定，应尽量做到物尽其用。不能因为 switch 语句的效率高就一直使用，也不能因为 if 语句常用就不用 switch 语句。需要根据实际情况，具体问题具体分析，使用最适合的条件语句。
一般情况下，对于判断条件较少的，可以使用 if 条件语句，但是在实现一些多条件的判断中，最好使用 switch 语句。
三、while和do while循环
3.1、While语法：
while循环：
* 语法：
* while (循环条件) {
* 循环体
* }
do while:
* 语法：
* do{
* 循环体
* } while (循环条件);
3.2
区别： /**
* while循环与do...while循环的区别：
* 1、while是先判断后执行，do...while循环是先执行然后再判断
* 2、do...while循环至少执行一次
* while循环与do...while的特点：都是循环执行某一语句，循环次数素不固定
3.3课堂实例
| public class Demo01 {
|
一、for循环嵌套
1.1、嵌套循环既可以是 for循环嵌套 while 循环，也可以是 while 循环嵌套 do-while 循环 …… 即各种类型的循环都可以作为外层循环，也可以作为内层循环。
当程序遇到嵌套循环时，如果外层循环的循环条件允许，则开始执行外层循环的循环体，而内层循环将被外层循环的循环体来执行——只是内层循环需要反复执行自己的循环体而已。
当内层循环执行结束，且外层循环的循环体执行结束时，则再次计算外层循环的循环条件，决定是否再次开始执行外层循环的循环体。
二、foreach 语句的用法
foreach 循环语句是 Java 1.5 的新特征之一，在遍历数组、集合方面，foreach 为开发者提供了极大的方便。foreach 循环语句是 for 语句的特殊简化版本，主要用于执行遍历功能的循环。
一和二课堂实例：
| public class Demo01 {
|
三、break 语句
3.1、某些时候需要在某种条件出现时强行终止循环，而不是等到循环条件为 false 时才退出循环。此时，可以使用 break 来完成这个功能。break 用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到 break，系统将完全结束该循环，开始执行循环之后的代码。
3.2、在 Java 中，break 语句有 3 种作用，分别是：在 switch 语句中终止一个语句序列、使用 break 语句直接强行退出循环和使用 break 语句实现 goto 的功能
3.3、使用 break 语句直接强行退出循环
可以使用 break 语句强行退出循环，忽略循环体中的任何其他语句和循环的条件判断。在循环中遇到 break 语句时，循环被终止，在循环后面的语句重新开始。
3.4、break 语句
某些时候需要在某种条件出现时强行终止循环，而不是等到循环条件为 false 时才退出循环。此时，可以使用 break 来完成这个功能。break 用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到 break，系统将完全结束该循环，开始执行循环之后的代码。
在 Java 中，break 语句有 3 种作用，分别是：在 switch 语句中终止一个语句序列、使用 break 语句直接强行退出循环和使用 break 语句实现 goto 的功能
1、使用 break 语句直接强行退出循环（break 不带标签）
可以使用 break 语句强行退出循环，忽略循环体中的任何其他语句和循环的条件判断。在循环中遇到 break 语句时，循环被终止，在循环后面的语句重新开始。
方法的调用：
调用方法：对象名.方法名(实参列表)，类名.方法名()。
Java支持两种调用方法的方式，根据方法是否有返回值来选择：
（1）当方法有返回值时，方法调用通常被当作一个值，例如：
int num = max(30, 40);
（2）如果方法返回值类型是void时，方法调用一定是一条语句，例如：
System.out.println(“Hello World”);
System.out.println( message() );
方法重载：
重载就是在一个类中，有相同的函数名称，但参数列表不相同的方法。
方法重载的规则：
方法名字必须相同
参数列表必须不同（参数个数不同、类型不同、参数排列顺序不同等）
方法的返回值可以相同，也可以不同（方法的重载与返回值类型无关）。
仅仅只是返回类型不同的话，则不足以称为方法的重载。
方法签名：
方法名+参数列表
重载方法调用规则：
编译器在编译时会根据方法的签名自动绑定调用的方法
算法案例：
| package com.zpark.day08; |
| package com.zpark.day08; |
递归算法
是一种直接或者间接地调用自身的算法。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。
**递归算法：**在函数或子过程的内部，直接或者间接地调用自己的算法。
**递归算法的实质：**是把问题转化为规模缩小了的同类问题的子问题。然后递归调用函数(或过程)来表示问题的解。
**递归算法解决问题的特点：**
(1) 递归就是在过程或函数里调用自身。
(2) 在使用递增归策略时，必须有一个明确的递归结束条件，称为递归出口。
(3) 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
(4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。
**递归的两个条件：**
1、可以通过递归调用来缩小问题规模，且新问题与原问题有着相同的形式。（自身调用）
2、存在一种简单情境，可以使递归在简单情境下退出。（递归出口）
**递归三要素：
1、一定有一种可以退出程序的情况；
2、总是在尝试将一个问题化简到更小的规模
3、父问题与子问题不能有重叠的部分
| package com.zpark.day08; |
一、数组
**数组的定义：**
相同数据类型元素的集合、是一种数据类型(引用类型)
**数组的声明：**
首先必须先声明数组变量，然后才能在程序中使用数组，数组的定义方式有如下几种：
```java
int[ ] arr;
或者
int arr[ ];
``
使用new关键字来声明数组：例如，
```java
int[ ] arr = new int[ 数组长度 ];
```
**数组元素赋值：**
```java
arr[i] = 10;
```
**访问数组：**
数组的访问是通过数组的下标来进行访问的，数组下标（索引）从0开始
**获取数组的长度：**
```java
arr.length
```
**数组的四个基本特点：**
1、 数组一旦被创建，它的大小将不可以在被改变。
2、 数组元素必须是相同类型的，不允许出现混合类型。
3、 数组中的元素可以是任何类型，包括基本类型与引用类型。
4、 数组属于引用类型，数组可以看成是一个对象，数组中的每一个元素相当于该对象的成员变量，因为数组本身就是对象，Java中对象是存放在堆中的，因此数组无论保存原始类型还是其他类型，数组对象本身都是在堆中。
数组的下标合法区间为：`[0，length-1]`，如果在这个范围之外将会报错，这种情况称为数组下标越界。例如：
```java
public static void main(String args[]){
int[] arr = new int[2];
// 下列代码将在运行时出现ArrayIndexOutOfBoundsException异常
System.out.ptintln(arr[2]);
}
```
> **注意：**
> 1、 数组是相同数据类型（数据类型可以为任意类型）的有序集合。
> 2、 数组也是对象，数组元素相当于对象的成员变量。
> 3、 数组一旦声明，长度就已经确定，不可以再被改变，如果越界，则会报：ArrayIndexOutOfBoundsException异常
算法案例：
| package com.zpark.day09; |
（三）
、冒泡排序
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。### 7.2.1、算法描述 1、比较相邻的元素。如果第一个比第二个大，就交换它们两个； 2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数； 3、针对所有的元素重复以上的步骤，除了最后一个； 4、重复步骤1~3，直到排序完成。
public static void main(String[] args) {
int arr[] = {6,9,3,5,2,8};
System.out.println("排序前：");
System.out.println(Arrays.toString(arr));
for(int i =0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
int tamp = 0;
if (arr[j]>arr[j+1]) {
tamp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tamp;
}
}
}
System.out.println("排序后：");
System.out.println(Arrays.toString(arr));
}
} |
三、选择排序
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
一、面向对象
面向过程思想：
1、 步骤清晰简单，第一步要做什么，第二步要做什么……
2、 面向过程适合处理一些较为简单的问题
面向对象思想：
1、 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后，才对某个分类 下的细节进行面向过程的思索。
2、 面向对象适合处理复杂的问题，适合处理需要多人协作的问题
面向过程的结构化程序设计：
结构化程序设计的弊端：
1、缺乏对数据的封装
2、数据与方法(操作数据)的分离
类是对象的抽象，对象都是类的属性.
2．什么是面向对象：
面向对象的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
3、类中可以包含:
3.1、所有对象所共有的属性/特征------------成员变量
3.2、所有对象所共有的行为-----------------方法
4、一个类可以创建多个对象
同一类型所创建的对象，结构相同，数据不同
- 类是对象的模板，对象是类的具体的实例
- 面向对象的三大特征：封装、继承、多态
所谓的OOP就是指的面向对象编程.这是一种计算机编程架构.OOP的一条基本准则是计算机程序是由单个能够引
* 起子程序作用的单元或对象组合而成.OOP达到了软件工程的三个主要目标:重用性,灵活性和扩展性.为了实现
* 整体运算,每个对象都能够接收消息,处理数据和向其它对象发送消息.OOP主要有以下的概念和组件.
*
* 组件: 数据和功能一起在运行着的计算机程序中形成的单元,组件在OOP计算机称重是模块和结构化的基础.
*
* 抽象性: 程序有能力忽略正在处理中信息的某些方面,即对信息主要方面关注的能力
*
* 封装: 也叫作信息封装:确保组件不会以不可预期的方式改变其它组件内部状态;只有在那些提供了内部状态改变方法的
*
* 组建中,才可以访问其内部状态.每类组件都提供了一个与其它组件联系的接口.并规定了其它组件进行调用的方法.
*
* 多态性: 组件的引用和类集会涉及到其它许多不同类型的组件,而且引用组件所产生的的结果得依据实际调用的类型.
*
* 继承性: 允许在现存的组件基础上创建子类组件,着统一并强调了多态性和封装性.典型的来说就是用类来对组件进行分
* 组,而且还可以定义新类为现存的类的扩展,这样就可以将类组织成树形或网状结构,这体现了动作的通用性.
*
* 由于抽象性/封装性/重用性以及便于使用等方面的原因,以组件为基础的编程在脚本语言中已经变得特别
* 流行.Python 和 Ruby 是最近才出现的语言，在开发时完全采用了 OOP 的思想，而流行的 Perl 脚本
* 语言从版本5开始也慢慢地加入了新的面向对象的功能组件。用组件代替“现实”上的实体成为 JavaScript（ECMAScript）
* 得以流行的原因，有论证表明对组件进行适当的组合就可以在英特网上代替 HTML 和 XML 的文档对象模型（DOM）。
二、类与对象的创建
*/
public class Student {
// 内部类
private class C{
}
}
// 定义类A
class A{
}
// 注意：一个java文件中只能有一个public修饰的Java类，并且这个被public修饰的Java类名必须与Java文件名字一致
//public class B{
//
//}
课堂实例：
| // 定义成员变量 // 定义方法 public void run(){ System.out.println("人在跑"); } public void eat(){ System.out.println("人在吃饭"); } // 将数组排序 public int[] sort(int[] arr){ Arrays.sort(arr); return arr; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + ", height=" + height + '}'; } } |
6.2创建对象：
| /** * 创建对象语法： * 数据类型 引用类型变量 指向(引用) new关键字 对象 * Student zs = new Student(); */ // 案例：创建Person对象 Person per = new Person(); // 实例化对象 // 访问对象的成员变量和方法，语法：对像名.成员变量名字/方法名字, 能点出什么东西全看类有什么东西 // 访问person类的成员变量 per.name = "大锤"; // 访问name变量并且赋值 // per.salary = 3000; 错误演示 System.out.println(per.toString()); per.age = 25; per.height = 177.777; System.out.println(per.toString()); // 访问变量 System.out.println(per.name); // 访问成员方法 per.run(); int[] ar = {1, 56, 0, 89, 78, 45}; int[] arr = per.sort(ar); System.out.println(Arrays.toString(arr)); // 实例化对象p2 Person p2 = per; // 将per的值（对象地址信息）赋给p2，此时per和p2指向相同对象 System.out.println(p2.toString()); Person p3 = new Person(); System.out.println(p3.toString()); Person p4 = null; /** * Exception in thread "main" java.lang.NullPointerException * 空指针异常： * 造成空指针异常的原因：是因为对象为null,然后访问其对象变量或者方法 */ // System.out.println(p4.toString()); } } |
二、面向对象分析产生三种模型
1、对象模型：对用例模型进行分析，把系统分解成互相协作的分析类，通过类图\对象图描述对象\对象的属性\对象间的关系，是系统的静态模型
2、动态模型：描述系统的动态行为，通过时序图/协作图/描述对象的交互，以揭示对象间如何协作来完成每个具体的用例。单个对象的状态变化/动态行为可以通过状态图来表示。
3、功能模型（即用例模型à作为输入）
Java-核心编程实验课堂笔记笔记（五）
三、构造方法构造方法语法结构：
构造方法是在类中定义的方法，不同于其他的方法，构造方法的定义有如下两点规则：
（1）构造方法的名称必须与类名完全相同。
（2）构造方法没有返回值，连void关键字有没有构造方法的语法：
构造方法的作用：用于创建类的对象（实例化对象），还可以初始化成员比啊量的初始值
注意：当我们手动添加构造器（构造方法）之后，编译器将不在为我们添加默认的无参构造器默认的构造方法：
- 任何一个类都必须含有构造方法。
- 如果源程序中没有定义构造方法，编译器在编译时会为其添加一个无参的构造方法（称为默认无参构造器）。
- 当定义了构造方法之后，Java编译器不再添加默认的无参构造器。
构造方法的重载：
一个类定义多个构造方法，这些构造方法都有相同的名称，但是方法的参数列表不同
一个构造方法可以通过this关键字调用另外一个重载的构造方法
构造方法常用于实例化对象和对成员变量进行初始化
this关键字的使用：
this关键字用在方法体中，用于指向调用该方法的当前对象，简单来说，那个对象调用方法，this就指的是那个对象，严格来讲在方法中需要通过this关键字指明当前对象。
Java内存分析
堆: new出来的对象(包括实例变量)
栈:局部变量(包括方法的参数)
方法区: .class字节码文件(包括方法、静态变量)
内存区域类型：1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制；
2. 堆：存放所有new出来的对象；
3. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中(对象可能在常量池里)（字符串常量对象存放在常量池中。）；
4. 静态域：存放静态成员（static定义的）；
5. 常量池：存放字符串常量和基本类型常量（public static final）。有时，在嵌入式系统中，常量本身会和其他部分分割离开(由于版权等其他原因)，所以在这种情况下，可以选择将其放在ROM中 ；
6. 非RAM存储：硬盘等永久存储空间
对于string的特殊解释
对于字符串：其对象的引用都是存储在栈中的，如果是编译期已经创建好(直接用双引号定义的)的就存储在常量池中，如果是运行期（new出来的）才能确定的就存储在堆中。对于equals相等的字符串，在常量池中永远只有一份，在堆中有多份。
对于通过new产生一个字符串（假设为”china”）时，会先去常量池中查找是否已经有了”china”对象，如果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”china”对象的拷贝对象。
这也就是有道面试题：String s = new String(“xyz”);产生几个对象？答：一个或两个，如果常量池中原来没有”xyz”,就是两个。
堆: 1.1） 存储new出来的对象(包括实例变量)
1.2) 垃圾: 没有任何引用所指向的对象
垃圾回收器(GC)**不定时到内存中清理垃圾，
回收过程是透明的(看不到的)，不一定一发现垃圾就立刻回收，
调用System.gc()可以建议虚拟机尽快调度GC来回收
1.3) 内存泄漏: 不再使用的内存没有被及时的回收
建议: 对象不再使用时及时将引用设置为null
1.4) 实例变量的生命周期:
在创建对象时存储在堆中，对象被回收时一并被回收
2) 栈:
2.1) 存储正在调用的方法中的所有局部变量(包括方法的参数) 2.2) 调用方法时，会在栈中为该方法分配一块对应的栈帧，
栈帧中存储方法中的局部变量(包括参数)，
方法调用结束时，栈帧被清除，局部变量一并被清除
2.3) 局部变量的生命周期: 方法被调用时存储在栈中，方法结束时与栈帧一并被清除
3) 方法区:
3.1) 存储.class字节码文件(包括静态变量、方法)
3.2) 方法只有一份，通过this来区分具体的调用对象对象数组数组是对象：
1、在Java中，数组属于引用数据类型。
2、数组对象存储在堆中，数组变量属于引用类型，存储数组对象的地址信息，指向数组对象。
数组的元素可以看成数组对象的成员变量（只不过类型全部相同）
访问控制修饰符
private修饰的成员变量和方法仅仅只能在本类中访问调用。
public修饰的成员变量和方法可以在任何地方调用，public修饰的内容是对外提供可以被调用的功能，需要相对稳定，private修饰的内容是对类实现的封装，如果“公开”会增加维护的成本。
protected和默认访问控制
- 用protected修饰的成员变量和方法可以被子类及同一个包中的类使用。
2）默认的访问控制即不书写任何访问修饰符，默认访问控制的成员变量和方法可以被同一个包中的类调用
封装
封装，简单的说就是该露的露，该藏的藏。我们在设计程序是要追求“高内聚，低耦合”，其中，高内聚指的是类的内部数据操作细节由自己完成，不允许外部干涉。低耦合指的是仅暴露少量的方法给外部调用（使用get/set方法）。
封装（对数据的隐藏），通常来说，应禁止直接访问应该对象中数据的实际表示，而是应该通过操作接口来访问，这种称为信息隐藏。
封装的意义：
- 对外提供可调用的，稳定的功能。
- 封装容易变化的，具体的细节，外界不可访问，这样封装的意义在于：
- 降低代码出错的可能性，便于维护。
- 当内部的实现细节改变时，只要保证对外的功能定义不变，其他的模块就不会因此而受到牵连。
封装的核心：属性私有化，行为（方法）公开化
继承
1、通过extends关键字可以实现类的继承。
2、子类可以继承父类的成员变量及成员方法，同时也可以定义自己的成员变量和成员方法。
3、Java语言不支持多重继承，一个类只能继承一个父类，但是一个父类可以有多个子类。
1、子类的构造方法中必须通过super关键字调用父类的构造方法，这样可以妥善的初始化继承自父类的成员变量。
2、如果子类的构造方法中没有调用父类的构造方法，Java编译器会自动的加入对父类的无参构造方法的调用（如果父类没有无参构造方法，则会有编译错误）。
多态
多态指的是同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但是可以指向对象的引用的类型有很多。
多态存在的条件：
1、 有继承关系
2、 子类重写父类的方法
3、 父类引用指向子类对象
多态的意义:
1、行为的多态(所有抽象方法都是多态的)
2、对象的多态(所有对象都是多态的)
多态的表现形式:
1、重写:根据对象的不同来表现多态
2、重载:根据参数的不同来表现多态
注意：多态是方法的多态性，不是属性的多态性
super关键字
在java里面，对于super关键字通常有两种用法：
-
-
-
- 用在子类的构造方法里（初始化用），主要是调用父类的默认构造方法，如果父类有不止一个构造方法，可以通过super指定具体的构造函数，比如 super(paras)。
- 用在子类里调用隐藏或重写的属性或行为，比如 super.onDestroy()等等。对于第1种需要注意，super表示当前类的父类对象，super()调用的是父类默认的构造方法，即这样可以对父类进行初始化。如果没有对父类进行初始化，当子类调用父类的方法时，便会从逻辑上出现错误，因为没对父类初始化，父类的方法和属性便没有内存空间。
-
-
关于super 与 this 关键字的对比（区别）
-
-
-
-
-
-
- super（参数）：调用基类中的某一个构造函数（应该位于子类构造函数中的第一条语句）。
-
-
-
-
- this（参数）：调用本类中的构造函数（应该位于构造函数中的第一条语句）。
-
- super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）。
- this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）
-
-
- 调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
- super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它构造方法。
- super()和this()均需放在构造方法内第一行。
- 尽管可以用this调用一个构造器，但却不能调用两个。
- this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
- this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
- 从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。
方法重写
方法的重写(Override):
1、发生在父子类中，方法名称相同，参数列表相同，方法体不同2、重写方法被调用时，看对象的类型
3、遵循"两同两小一大"原则:------------了解
3.1、两同:
3.1.1、方法名称相同
3.1.2、参数列表相同
3.2、两小:
3.2.1、派生类方法的返回值类型小于或等于超类方法的
a、void时，必须相同
b、基本数据类型时，必须相同
c、引用数据类型时，小于或等于
3.2.2、派生类方法抛出的异常小于或等于超类方法的
3.3、一大:
3.3.1、派生类方法的访问权限大于或等于超类方法的
重写与重载的区别:
1、重写(Override):
1.1、发生在父子类中，方法名相同，参数列表相同，方法体不同 1.2、"运行期绑定"，看对象的类型绑定方法
2、重载(Overload):
2.1、发生在一个类中，方法名相同，参数列表不同，方法体不同
2.2、"编译期绑定"，看参数/引用的类型绑定方法
补充：
编译期:.java源文件，经过编译，生成.class字节码文件
运行期:JVM加载.class并运行.class
编译错误:只是检查语法
Java-核心编程实验笔记（六）
一、设计模式的分类
总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任键模式、合令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其实还有两类：并发型模式和线程池模式。
二、设计模式的六大原则↵
1、开闭原则(Open Close Principle)
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级，想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
2、里氏代换原则(Liskov Substitution Principle)
里氏代换原则(Liskoy Substitution Principle LSP)面向对象设计的基本原则之一。里氏代换原则中说,任何基类可以出现的地方，子类一定可以出现。LSP是继承复用的基石，只有当初生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化，直基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。——From Baidu百科↵
3、依赖倒转原则(Dependence Inversion Principle)
这个是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。
4、接口隔离原则(Interface Segregation Principle)↵
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低耦合。
5、迪米特法则(最少知道原则) (Demeter Principle)
为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
6、合成复用原则(Composite Reuse Principle)
原则是尽量使用合成/聚合的方式，而不是使用继承。
十三、static和final关键字
1、static修饰成员变量
1、用static修饰的成员变量不属于对象的数据结构，属于类的数据结构。
2、static变量是属于类的变量，通常可以通过类名来引用static成员。
3、static成员变量和类的信息一起存储在方法区，而不是在堆中，一个类的static变量只有一份，无论这个类创建了多少个对象。
2、static修饰方法
1、通常的方法都会涉及到对具体对象的操作，这些方法在调用时需要隐式传递对象的引用（this）。
2、static修饰的方法则不需要针对某些对象进行操作，其运行结果仅仅与输入的参数有关，调用时直接用类名引用。
3、static在调用时没有具体的对象，因此在static方法中不能对非static成员进行访问，static方法的作用在于提供一些“工具方法”和“工厂方法”等。
3、static静态块
Static块属于类的代码块，在类加载期间指向代码块，只执行一次，可以用来在软件中加载静态资源。
课堂实例：
| public class Demo01 { public static String name = "张三"; public String name1 = "张三"; public static void run(){ System.out.println("我是静态方法"); } public static void main(String[] args) { |
最低0.47元/天 解锁文章
250
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
