第一章.基础必备知识
java语言特性：
简单性：相对其他语言简单
面向对象：符合人的思维模式，容易理解
可移植性
多线程
健壮性：自动垃圾回收机制，简称GC机制
java语言运行过程中产生的垃圾是自动回收的
安全性
public class Hello{ //hello是一个类，是一个public类
public static void main(String[] args){ //表示一个主方法，即程序的入口
System.out.pringln("hello world~")； //输出 hello world到屏幕
}
}1.一个源文件中最多只能有一个public类，其它类的个数不限
2.如果源文件包含一个public类，则文件名必须按该类名命名
3.一个源文件中最多只能有一个public类，其它类的个数不限，也可以将main方法写在非public类中，然后指定运行非public类，这样入口方法就是非public的main方法
1.1 java转义字符：
\t:一个制表位，实现对齐功能
\n：换行符
\\：输出一个\，第一个\为转义字符
\"：一个"
\'：一个’
\r：一个回车 System.out.println("哈哈哈\r嘿嘿")； 只输出嘿嘿
在IDE输入tal键可以补全编译
1.2 Java代码规范：
类，方法的注释要以javadoc来注释
代码不整齐，选中，然后按Tab整体右移。选中，按shift+tab整体右移
多行注释快捷键 ctrl+/，再次输入就取消注释
1.3 变量：
变量三个基本要素：类型+名称+值
int a=1; System.out.println(a); 4个字节
int age=20;
double score=88.6; 8个字节
char gender='男'; 1个字节
String name='Jack'; //字符串
标识符：由数字，字母，下划线_和美元$组成
不能以数字开头
不能是关键字
区分关键字
变量使用注意事项：
变量在同一作用域内不能重名
System.out.println(100+90); //190
System.out.println("100"+90); //10098做拼接
System.out.println(100+90+"hello"); //103hello 先运算后拼接
System.out.println("hello"+100+90); //hello1003 拼接程序中 +号的作用：
1.当左右两边都是数值型时，做加法运算
2.当左右两边有一方为字符串，做拼接运算
3.运算顺序从左到右
1.4 数据类型
基本数据类型
<1> 数值型： 【】为占用存储空间
整数类型：byte[1] short[2] int[4] long[8]
byte n1=10; 这个10占用1个字节大小
short n2=10; 这个10占用2个字节大小
long int 占8个字节，正确书写 long n1=1l System,out,println(n1) 输出为1
浮点类型：float[4] double[8]
float num1=20.1f 输出20.1
double num2=35.6f 也是可以存放的
<2> 字符类型: char[2] 存放单个字符
char c1='a';
char c1='a'; System.out.println((int)c1); //将a的值转换为ASCII码所对应的值
char n1='A'+1;
System.out.println((int)n1); //输出66
System.out.println(n1); //输出B
char c2='\t';
char c3='韩'；
char c4=97; //字符类型可以直接存放数字
<3>布尔型（boolean[1]）,存放true,false,无null
注：在java语言中不能用0或者1来表示真假
引用数据类型
类（class）: String本质是字符数组
接口(interface):
数组([ ]):
自动类型转换细节：
byte b2=1;
byte b3=2;
short s1=1; //short s2=b2+s1;error b2+s1=>int
int s2=b2+s1; //pass b2+b3=>int
byte b4=b2+b3; //error b2+b3=>int
boolean 不参与转换强制类型转换：
强转符号只针对最近的操作数有效，往往会使用小括号提升优先级
int x=(int)10*3.5+6*1.5 double->int
正确做法：int x=(int）（10*3.5+6*1.5）
基本数据类型和String类型转换：
基本类型转字符串：基本类型的值+""
int n1=100;
float f1=1.1F;
double d1=4.5;
boolean b1=true;
String s1=n1+"";
String s2=f1+"";
String s3=d1+"";
String s4=b1+"";\
System.out.println(s1+""+s2+""+s3+""+s4);
第二章.运算符
2.1 算术运算符
注意：10%3=1 -10%3=-1 10% -3=1 -10% -3=-1
10.0/4=2.5 10.0为double类型
double d=10/4 结果是2.0
int i=10;
i++;
System.out.println("i="+i);
int days=59;
int weeks=days /7;
int leftdays=days %7;
System.out.println(days+"天 合"+weeks+"星期零"+leftdays++"天"); double tem1=369;
double tem2=5.0/9*(tem1-100);
System.out.println("华氏温度"+tem1+"对应的摄氏温度"+tem2);2.2 赋值运算符
+= -= /= %= *=
2.3 关系运算符（比较运算符）
关系运算符的结果都是boolean型，要么是true，要么是false
比较运算符是“==”
2.4 逻辑运算符
&&与&使用区别：
对于&&短路与而言，如果第一个条件为false，后面的条件不再判断
对于&逻辑与而言，如果第一个条件为false，后面的条件依然执行
||与|使用区别：
||短路或：如果第一个条件为true，第二个条件不会判断，最终结果为true
|逻辑或：不管第一个条件是否为true，第二个条件都要判断
2.5 位运算符
2.6 三目运算符（三元运算符）
条件表达式？表达式1：表达式2；
1.如果条件表达式为true，运算后结果是表达式1
2.如果条件表达式为false,运算后结果是表达式2
int a=10;
int b=99;
int result=a>b?a++：b--; //执行表达式b--，先赋值后自减 输出为99int n1=2;
int n2=3;
int n3=5;
int max1=n1>n2?n1:n2;
int max2=max1>n3?max1:n3;
System.out.println("最大数="+max);2.7 运算符优先级
1） （）{}
2）单目运算符 ++ --
3）算术运算符
4）位移运算符 》《
5）比较运算符
6）逻辑运算符
7）三元运算符
8）赋值运算符
标识符的命名规则和规范
1.自己起名字的地方都叫标识符 int num1=90；
标识符的命名规则：
1.由26个英文字母大小写，_或$组成
2.数字不可以开头。int 3ab=1;
3.不可以使用关键字和保留字，但可以包含关键字和保留字
4.标识符不能包含空格。int a b=90;
5.小驼峰命名法：（方法，变量）
标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写
如：firstName
6.大驼峰命名法：（类）
标识符是一个单词，首字母大写。如：Student
标识符由多个单词组成的时候，每个单词的首字母大写
如：GoodStudent
键盘输入语句：
input.java 需要一个扫描器（对象），就是Scanner(类)
步骤：
1）导入该类的所在包：import java.util.Scanner
2)创建该类对象（声明变量）--表示我要开始用Scanner这个类了
Scanner sc=new Scanner(System.in)
3)接收数据
int i=sc.nextInt(); 变量i记录了键盘录入的数据
原码：
反码：
补码：
第三章.流程控制
3.1顺序结构
3.2 分支结构
if语句
if(wine>2){
System.out.println("小伙子，不错呦")；
}
if(price>=100){
System.out.println("网红餐厅");
}
else {
System.out.println("沙县小吃");
}switch-case语句
switch(表达式){
case 值1：
语句体1；
break;
case 值2：
语句体2；
break;
case 值3：
语句体3；
break；
default:
语句体n+1；
break;
}
如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，结束整个switch语句
package xunhuan_test;
import java.util.Scanner;
public class instance01 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入你想吃的面:");
String str = sc.next();
switch (str){
case "兰州拉面":
System.out.println("吃拉面");
break;
case "热干面":
System.out.println("吃热干面");
break;
case"炸酱面":
System.out.println("吃炸酱面");
break;
default:
System.out.println("吃泡面");
break;
}
}
public static class test6 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请录入星期：");
int day=sc.nextInt();
switch(day){
case 1:
System.out.println("跑步");
break;
case 2:
System.out.println("游泳");
break;
case 3:
System.out.println("慢走");
break;
case 4:
System.out.println("动感单车");
break;
case 5:
System.out.println("拳击");
break;
case 6:
System.out.println("爬山");
break;
case 7:
System.out.println("好好吃一顿");
break;
}
}
}循环
for循环
for(i=0;i<10;i++){
执行语句；
}
while循环
while(i<=100){
System.out.println(i);
i++;
}
public class test12 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("输入数字：");
int number=sc.nextInt();
int num=0;
//利用循环从右往左获取数字
while(number!=0){
int ge=number%10;
//将取模后的x重新赋给x
number=number/10;
num=num*10+ge;
}
System.out.println(num);
}
} 
for和while对比
for循环中：知道循环次数或者循环的范围
while循环中：不知道循环的次数和范围，只知道循环的结束条件
跳转控制语句
循环控制当中跳转到其他语句
案例1：小老虎吃包子跳转第3个包子
for(int i=1;i<=5;i++){
if(i==3){
continue;
}
}
System.out.println("小老虎在吃第"+i+"个包子");
for(i=1;i<=5;i++){
System.out.println("小老虎在吃第"+i+"个包子");
if(i==3){
break;
}
}
练习：
test1.
/*朋友聚会的时候会玩一个游戏：逢7过
游戏规则：从任意一个数字开始报数，当你要报的数字包含7或者是7的倍数时都要说过：过
需求：使用程序控制台打印除1-100之间的满足逢7必过规则的数据
*/
test2.
/*求平方根
需求：键盘录入一个大于等于2的整数x，计算并返回x的平方根。
结果只保留整数部分，小数部分将被舍去
*/
test3.
第四章.数组
4.1数组的概述和静态化
概述：用来存储同种数据类型的多个值
静态初始化：
int []arr=new int[]{1,2,3,4,5};
int []arr={1,2,3,4,5};//简化格式
String []arr1={"zhangsan","lisi","wangwu"};
double []arr2={1.93,1.88,1.75};4.2打印数组/数组元素访问：
System.out.println(arr); //表示打印数组第一个地址
System.out.println(arr[1]); //表示打印数组中第2个元素
System.out.println(arr[i]); // 表示打印数组的所有元素
动态初始：
int []arr=new int[3];注：在创建的时候，有我们给定数组长度，由虚拟机给出默认的初始化值。
int 默认初始化值为0
String 默认初始化为 null
求数组元素最小值
public class test1 {
public static void main(String[] args) {
int []arr={33,5,22,44,55};
int max=arr[0];
for(int i=1;i< arr.length;i++){
if(arr[i]>max){
max=arr[i];
}
}
System.out.println(max);
}
}import java.util.Random;
public class test2 {
public static void main(String[] args) {
int [] arr=new int[10];
Random random=new Random();
/*所有数据的和*/
int sum=0;
for (int i = 0; i < arr.length; i++) {
arr[i]=random.nextInt(100) ;
sum+=arr[i];
}
System.out.println("数组所有元素的和为："+sum);
/*求所有数据的平均数*/
double avg=0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
avg=sum/ arr.length;
}
System.out.println("所有数据的平均数为："+avg);
/*统计有多少个数据比平均值小*/
int count=0;
for (int i = 0; i < arr.length; i++) {
if(arr[i]<avg){
count++;
}
}
System.out.println("数据比平均值小的个数为："+count);
}
}4.3数组遍历
public class instance1 {
public static void main(String[] args) {
int []arr={1,2,3,4,5,6,7};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}4.4练习
4.4.1打乱数据
import java.util.Random;
public class instance1 {
public static void main(String[] args) {
int []arr={1,2,3,4,5,6};
Random r=new Random();
//循环遍历数组
for (int i = 0; i < arr.length; i++) {
int randomIndex=r.nextInt(arr.length);//获取数组里面随机索引
int temp=arr[i];
arr[i]=arr[randomIndex];//随机索引原数组元素
arr[randomIndex]=temp;
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
第五章.方法
5.1基础概念
什么是方法？
方法：程序中最小的执行单元
方法作用：提高代码的重复性
提高代码可维护性
什么时候用到方法？
重复的代码，具有独立功能的代码可以抽取到方法中
方法定义：把一些代码打包在一起，然后调用
方法的格式：
1.最简单的方法定义：
public static void playGame(){
System.out.println("选人物");
System.out.println("准备开局");
System.out.println("GG");
}2.带参数的方法定义和调用：
public class test1 {
public static void main(String[] args) {
method(10,30);
}
public static void method(int num1 ,int num2){
int result=num1+num2;
System.out.println(result);
}
}注意：方法在调用时，参数的数量与类型必须与方法定义中小括号里面的变量一 一对应，否则程序将报错。
形参和实参
形参：形式参数，方法定义中的参数
实参：实际参数，方法调用中的参数
3.带返回值的方法的定义和调用
public class test1 {
public static void main(String[] args) {
int sum1=method(3,6,8);
int sum2=method(10,20,30);
int sum3=method(20,50,60);
System.out.println(sum1);
System.out.println(sum2);
System.out.println(sum3);
}
public static int method(int num1,int num2,int num3){
int result=num1+num2+num3;
return result;
}
}public class test1 {
public static void main(String[] args) {
double area1=compare(5.3,1.7);
double area2=compare(2.4,2.7);
if(area1>area2){
System.out.println("第一个长方形面积更大");
}else {
System.out.println("第二个长方形面积更大");
}
}
public static double compare(double len,double width){
double area=len*width;
return area;
}
}
方法返回值类型为void，表示该方法没有返回值
没有返回值的方法可以省略return语句不写。
如果要编写return，后面不能跟具体的数据
return：表示结束方法
5.2重载
重载关系：在同一类中，方法名相同，参数不同的方法。与返回值无关。
参数不同：个数不同，类型不同，顺序不同。
public class test2 {
public static void fn(int a ){
}
public static int fn(int a ){
}
}
//不构成重载关系
重载优点：1.定义方法可以不用那么多单词
2.调用方法的时候不需要那么麻烦了
public class test2 {
public static void main(String[] args) {
System.out.println(1,2);//此时调用了int类型的compare
}
public static void compare(byte b1,byte b2){
System.out.println("n1=n1");
}
public static int compare(short s1,short s2 ){
System.out.println("m1=m1");
}
public static int compare(int i1,short i2 ){
System.out.println("s1=s1");
}
public static int compare(long l1,long l2 ){
}
}5.3练习
5.3.1
public class test2 {
public static void main(String[] args) {
int []arr={11,22,33,44,55};
printArr(arr);
}
public static void printArr(int []arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
System.out.print(arr[i]);
}else{
System.out.print(arr[i]+",");
}
}
System.out.print("]");
}
}
5.3.2用方法获取数组中的最大值：
public class test2 {
public static void main(String[] args) {
int []arr={1,5,7,3,8,9};
int max=getMax(arr);
System.out.println(max);
}
public static int getMax(int []arr){
int max=arr[0];
for (int i = 1; i < arr.length; i++) {
if(arr[i]>max){
max=arr[i];
}
}
return max;
}
}5.3.3用方法判断数字是否在数组中：
public class test2 {
public static void main(String[] args) {
int []arr={1,5,7,3,8,9};
int max=getMax(arr);
System.out.println(max);
}
public static int getMax(int []arr){
int max=arr[0];
for (int i = 1; i < arr.length; i++) {
if(arr[i]>max){
max=arr[i];
}
}
return max;
}
}
5.3.4复制数组：
需求：定义一个方法copyOfRange（int []arr,int from,int to）
功能：将数组arr中从索引from（包含from）开始。到索引to结束（不包含to）的元素复制到新数组中，将新数组返回。
public class test4 {
public static void main(String[] args) {
//1.定义原始数组
int []arr={1,2,3,4,5,6,7,8,9};
//2.调用方法拷贝数据
int[] arr1 = arr;//将arr[]中索引的元素重新赋值给新的数组
copyOfRange(arr1,3,7);
//3.遍历arr1，将arr中索引的元素复制到新的arr1
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i]+" ");
}
}
public static int[] copyOfRange(int[]arr,int from,int to){
//1.定义数组
//动态：不知道所有元素，知道要存几个元素
int []newArr=new int[to-from];
//2.把原始数组arr中的from到to上对应的元素，直接拷贝到new arr中
//3.伪造索引的思想
int index=0;
for (int i = from; i < to; i++) {
newArr[index]=arr[i];
index++;
}
return newArr;
}
}5.3.5卖飞机票
需求：
机票价格按照淡旺季，头等舱和经济舱收费，输入机票原价，月份和头等舱或经济舱
按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。
import java.util.Scanner;
public class exercise1 {
public static void main(String[] args) {
//键盘录入机票原价，月份，头等舱或经济舱
Scanner sc = new Scanner(System.in);
System.out.println("请输入机票的原价");
int ticket = sc.nextInt();
System.out.println("请输入当前的月份");
int month = sc.nextInt();
System.out.println("请输入当前购买的舱位 0 头等舱 ，1 经济舱");
int seat = sc.nextInt();
//先判断月份是旺季还是淡季
//继续判断当前机票是经济舱还是头等舱
//根据实际情况计算出对应的价格
if (month >= 5 && month <= 10) {
ticket=getPrice(ticket,seat,0.9,0.85);
} else if ((month >= 1 && month <= 4) || (month >= 11 && month <= 12)) {
ticket=getPrice(ticket,seat,0.7,0.65);
} else {
System.out.println("键盘录入的月份不合法");
}
System.out.println(ticket);
}
public static int getPrice(int ticket, int seat, double v0, double v1) {
if (seat == 0) {
ticket = (int) (ticket * 0.7);
} else if (seat==1) {
ticket = (int) (ticket * 0.65);
}else{
System.out.println("没有这个舱位");
}
return ticket;
}
}
5.3.6找质数
判断101-200之间有多少个质数，并输出所有素数
public class exercise2 {
public static void main(String[] args) {
int count=0;
for(int i=101;i<=200;i++) {
boolean flag = true;
for (int j = 2; j < i; j++) {
if(i%j==0){
flag=false;
break;
}
}
if(flag){
System.out.println("当前数字"+i+"是质数");
count++;
}
}
System.out.println("101-200为质数的个数是"+count);
}
}改良版：
package Fangfa_test;
import java.util.Scanner;
import static java.lang.Math.sqrt;
public class exercise2 {
public static void main(String[] args) {
//判断101-200之间有多少个素数，
Scanner sc=new Scanner(System.in);
System.out.println("请输入数字:");
int i=sc.nextInt();
boolean flag=true;
//只需要找开方后的数字就行了，减少循环次数
for(int j=2;j<sqrt(i);j++){
if(i%j==0){
flag=false;
break;
}
}
if(flag){
System.out.println("当前数字是质数");
}else{
System.out.println("当前数字不是质数");
}
}
}
5.3.7开发验证码
需求：
定义方法实现随机产生一个5位的验证码
验证码格式：
长度为5
前四位是大写字母或者小写字母
最后一位是数字
import java.util.Random;
public class exercise3 {
public static void main(String[] args) {
//大写字母小写字母都放到数组中
char []chs=new char[52];
for (int i = 0; i < chs.length; i++) {
if (i<=25) {
chs[i] = (char) (97 + i);
} else {
chs[i] = (char)(65+i-26);
}
}
//定义一个字符串类型的变量，用来记录最终的结果
String result="";
//随机抽取4次
Random r=new Random();
for (int i = 0; i < 4; i++) {
int randomIndex=r.nextInt(chs.length);
System.out.println(chs[randomIndex]);
result=result+chs[randomIndex];
}
//随机抽取一个数字0-9
int number=r.nextInt(10);
result=result+number;
System.out.println(result);
}
}
5.3.8数组元素的复制
需求：
把一个数组中的元素复制到另一个数组中
public class exercise4 {
public static void main(String[] args) {
int []arr={1,2,3,4,5};
//定义一个新数组，且长度与之前数组一致
int []newArr=new int[arr.length];
for (int i = 0; i < arr.length; i++) {
newArr[i]=arr[i];
}
for (int i = 0; i < arr.length; i++) {
System.out.println(newArr[i]);
}
}
}
5.3.9评委打分
需求：
在歌唱比赛中，有6名评委给选手打分，分数范围是【0-100】之间的整数，选手的最后得分为：去掉最高分，最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分
import java.util.Scanner;
public class exercise5 {
public static void main(String[] args) {
//定义一个数组用来存6个评委打分
int []scoresArr=getScore();
for (int i = 0; i < scoresArr.length; i++) {
System.out.println(scoresArr[i]);
}
//求出数组中的最大值
int max=getMax(scoresArr);
//求出数组中的最小值
int min=getMin(scoresArr);
//求出6个分数总和
int sum=getSum(scoresArr);
//（总和减去最大值最小值）/4
int avg=(sum-min-max)/(scoresArr.length-2);
System.out.println("评委打出的平均分为："+avg);
}
public static int [] getScore(){
int []scores=new int[6];
//键盘录入的形式输入分数：0-100
Scanner sc=new Scanner(System.in);
for (int i = 0; i < scores.length; ) {
System.out.println("请输入评委打分：");
int score=sc.nextInt();
if(score>=0&&score<=100){
scores[i]=score;
i++;
}
}
return scores;
}
public static int getMax(int[]scoreArr){
int max=scoreArr[0];
for (int i = 0; i < scoreArr.length; i++) {
if(max<scoreArr[i]){
max=scoreArr[i];
}
}
return max;
}
public static int getMin(int []scoreArr){
int min=scoreArr[0];
for (int i = 0; i < scoreArr.length; i++) {
if(min>scoreArr[i]){
min=scoreArr[i];
}
}
return min;
}
public static int getSum (int []scoreArr){
int sum=0;
for (int i = 0; i < scoreArr.length; i++) {
sum=sum+scoreArr[i];
}
return sum;
}
}5.3.10数字加密
需求：
某系统的数字密码（大于0），比如1983，采用加密方式进行传输。
规则如下：
先得到每位数，然后每位数都加上5，再对10求余，然后将所有数字反转，得到一串新数
public class test1 {
public static void main(String[] args) {
//把整数里面的每一位放到数组中
int [] arr={1,9,8,3};
//加密
//每位数字加5
for (int i = 0; i < arr.length; i++) {
arr[i]=arr[i]+5;
}
//再对10取余
for (int i = 0; i < arr.length; i++) {
arr[i]=arr[i]%10;
}
//将所有数字进行反转
for (int i = 0,j=arr.length-1; i < j; i++,j--) {
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
//把数组里面的每一位数字进行拼接，变成加密之后的结果
int number=0;
for (int i = 0; i < arr.length; i++) {
number=number*10+arr[i];
}
System.out.println(number);
}
}public class test2 {
public static void main(String[] args) {
//计算数组长度
int number=12345;
//定义一个临时变量记录number的值
int temp=number;
//定义一个变量进行统计
int count=0;
while (number!=0){
//每一次循环就去掉右边的一个数字
number=number/10;
//去掉一位计数器就自增一次
count++;
}
//定义数组
//动态初始化
int []arr=new int[count];
//把整数上的每一位都添加到数组中
int index=arr.length-1;
while(temp!=0){
int ge=temp%10;
temp=temp/10;
//把当前获取到的个位数添加到数组当中
arr[index]=ge;
index--;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]+" ");
}
}
}
5.3.11数字解密
public static void main(String[] args) {
//定义数组用来记录解密之后的结果
int []arr={8,3,4,6};
//arr.length-1最大索引开始减
for (int i = 0,j=arr.length-1; i < j; i++,j--) {
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
//由于加密是对10取余方式进行获取的
//所以解密的时候需要判断，0-4之间+10,5-9之间不变
for (int i = 0; i < arr.length; i++) {
if(arr[i]>=0&&arr[i]<=4){
arr[i]=arr[i]+10;
}
}
//每一位减5
for (int i = 0; i < arr.length; i++) {
arr[i]=arr[i]-5;
}
//获取数组里面的每一位数字，拼接成最终的结果
int number=0;
for (int i = 0; i < arr.length; i++) {
number=number*10+arr[i];
}
System.out.println(number);
}
}5.4方法的内存
5.4.1.方法调用的基本内存原理
栈：方法运行时使用的内存，方法进栈运行，运行完毕后就出栈
堆：new出来的，都在堆内存中开辟了一个小空间
方法区：存储可以运行的class文件
本地方法栈：JVM在使用操作系统功能的时候使用，和开发无关
寄存器：CPU使用
5.4.2.方法传递基本数据类型的内存原理
基本数据类型：
整数类型：int
浮点数类型:float
布尔类型:boolean
字符类型:char
数据值存储在自己的空间中
特点：赋值给其他变量，也是赋值的真实值
5.4.3.方法传递引用数据类型的内存原理
引用数据类型：其他数据类型
存储的是变量的地址值
引用：使用了其他空间中的数据
自己空间中存储的是地址值
比如数组，真实值存储在其他空间，自己空间存储的的是真实值的地址
int [ ]arr1={1,2,3};
int [ ]arr2=arr1; //两个变量指向了同一个空间
5.5方法的值传递
public class test1 {
public static void main(String[] args) {
int number=100;
System.out.println("调用change方法前："+number);
change(number);
System.out.println("调用change方法后："+number);
}
public static void change(int number){
number=200;
}
}
change方法结束后，出栈
最后输出两个100
结论：传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值
public class test1 {
public static void main(String[] args) {
int number=100;
System.out.println("调用change方法前："+number);
number= change(number);
System.out.println("调用change方法后："+number);
}
public static int change(int number){
number=200;
return number;
}
}
public class test1 {
public static void main(String[] args) {
int []arr={10,20,30};
System.out.println("调用change方法前："+arr[1]);
change(arr);
System.out.println("调用change方法后："+arr[1]);
}
public static void change(int []arr){
arr[1]=200;
}
}
结论：传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值
第六章面向对象
6.1面向对象基础
面向对象重点学习哪些内容？
1.学习获取已有对象并使用
2.学习如何自己设计对象并使用
6.1.1设计对象并使用
1.类和对象
类:是对象共同特征的描述
对象：是真实存在的具体东西
在java中，必须先设计类，才能获得对象
定义类：public class 类名{
1.成员变量（代表属性，一般是名词）
2.成员方法（代表行为，一般是动词）
3.构造器
4.代码块
5.内部类
}
public class phone {
//属性
String brand;
double price;
public void call(){
System.out.println("手机在打电话");
}
public void playGame(){
System.out.println("手机在玩游戏");
}
}
public class test1 {
public static void main(String[] args) {
//创建手机的对象
phone p=new phone();
//给手机赋值
p.brand="小米";
p.price=1999.98;
//获取手机对象中的值
System.out.println(p.brand);
System.out.println(p.price);
//调用手机中的方法
p.call();
p.playGame();
phone p2=new phone();
p2.brand="苹果";
p2.price=8999;
System.out.println(p2.brand);
System.out.println(p2.price);
p2.call();
p2.playGame();
}
}类名 对象名=new 类名（）；
对象.成员变量；
对象.成员方法；
类的几个补充注意事项：
用来描述一类事物的类，专业叫做：Javabean类
在javabean类中，是不写main方法的
编写main方法的类，叫做测试类
创建javabean类对象并进行赋值调用
注意：
1.类名首字母建议大写，需要见名如意，驼峰模式
2.一个java文件中可以定义多个class类，且只能一个类是public修饰，而且public修饰的类名必须成为代码文件名。实际开发中建议还是一个文件定义一个class类
3.成员变量的完整定义格式是：修饰符 数据类型 变量名称=初始化值；一般无需指定初始化值，存在默认值。
6.1.2封装
对象代表什么，就得封装对应的数据，并提供数据对应的行为
public class circle {
double radius;
public void draw(){
System.out.println("根据半径"+radius"画一个圆");
}
}
public class Door {
boolean flag=true;
public void open(){
}
public void close(){
}
}
6.1.3 private关键字
是一个权限修饰符
可以修饰成员（成员变量和成员方法）
被private修饰的成员只能在本类中才能访问
public class girlFriend {
private String name;
private int age;
private String gender;
}
public class girlFriend {
private String name;
private String gender;
private int age;
//针对每一个私有化的成员变量，都要提供get和set方法
//set方法：给成员变量赋值
//get方法：对外提供成员变量的值
//作用:给成员变量name进行赋值的
public void setName(String n){
name=n;
}
//作用：对外提供name属性
public String getName(){
return name;
}
public void setAge(int a ){
if(a>=18&&a<=50){
age=a;
}else{
System.out.println("非法参数");
}
}
public int getAge(){
return age;
}
public void setGender(String g){
gender=g;
}
public String getGender(){
return gender;
}
}
public class girlFriend_test {
public static void main(String[] args) {
//创建女朋友的对象
girlFriend gf1=new girlFriend();
//赋值
gf1.setName("小诗诗");
gf1.setAge(18);
gf1.setGender("女");
/* String name=gf1.getName();
int age=gf1.getAge();
String gender =gf1.getGender();*/
System.out.println(gf1.getName());
System.out.println(gf1.getAge());
System.out.println(gf1.getGender());
}
}6.1.4this关键字
成员变量和局部变量
方法外面叫成员变量
方法里面叫局部变量
age就近原则，下面打印age=10的值
public class girlF {
private int age;//成员变量
public void method(){
int age=10;//局部变量
System.out.println(age);
}
}
打印局部变量age=10的值public class girlF {
private int age;//成员变量
public void method(){
int age=10;//局部变量
System.out.println(this.age);
}
}
打印成员变量age的值public class girlFriend {
private String name;
private String gender;
private int age;
//针对每一个私有化的成员变量，都要提供get和set方法
//set方法：给成员变量赋值
//get方法：对外提供成员变量的值
//作用:给成员变量name进行赋值的
public void setName(String name){
//局部变量表示测试类中调用方法传递过来的数据
//等号左边，就表示成员位置的name
this. name=name;
//小诗诗传递给String name，然后把name赋值给成员变量的name
}
//作用：对外提供name属性
public String getName(){
return name;
}
public void setAge(int age){
if(age>=18&&age<=50){
this.age=age;
}else{
System.out.println("非法参数");
}
}
public int getAge(){
return age;
}
public void setGender(String gender){
this.gender=gender;
}
public String getGender(){
return gender;
}
}public class girlFriend_test {
public static void main(String[] args) {
//创建女朋友的对象
girlFriend gf1=new girlFriend();
//赋值
gf1.setName("小诗诗");
gf1.setAge(18);
gf1.setGender("女");
/* String name=gf1.getName();
int age=gf1.getAge();
String gender =gf1.getGender();*/
System.out.println(gf1.getName());
System.out.println(gf1.getAge());
System.out.println(gf1.getGender());
}
}
6.2构造方法
6.2.1构造方法的格式
构造方法也叫做构造器，构造函数。
作用：在创建对象的时候给成员变量进行初始化（赋值）的。
public class student{
修饰符 类名（参数）{
方法体；
}
}
特点：
1.方法名与类名相同，大小写也要一致
2.没有返回值类型，连void也没有
3.没有具体的返回值（不能由带return带回结果数据）
public class student {
private String name;
private int age;
public student(){
//空参构造，成员变量默认初始化值
}
public student(String name,int age){
//带全部参数的构造方法
}
}
注意：
1.创建对象的时候由虚拟机调用，不能手动调用构造方法
2.每创建一次对象，就会调用一次构造方法
public class student {
private String name;
private int age;
//如果我们自己没有写任何构造方法
//虚拟机会给我们加一个空参构造方法
public student(){
System.out.println("看看执行了吗？");
}
public void setName(){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(){
this.age=age;
}
public int getAge(){
return age;
}
}public class student_test {
public static void main(String[] args) {
//创建对象
//调用空参构造
student s=new student();
}
} 
含参构造
public class student {
private String name;
private int age;
//如果我们自己没有写任何构造方法
//虚拟机会给我们加一个空参构造方法
//系统给定的无参构造
public student(){
System.out.println("看看执行了吗？");
}
public student(String name,int age){
this.name=name;
this.age=age;
}
public void setName(){
this .name=name;
}
public String getName(){
return name;
}
public void setAge(){
this.age=age;
}
public int getAge(){
return age;
}
}public class student_test {
public static void main(String[] args) {
//创建对象
//调用空参构造
student s=new student("张三",23);
System.out.println(s.getName());
System.out.println(s.getAge());
}
} 
构造方法注意事项：
1. 如果没有定义构造方法，系统将给出一个默认的无参数构造方法
2.如果定义了构造方法，系统将不再提供默认的构造方法
构造方法的重载：
带参构造方法和无参构造方法，两者方法名相同，但是参数不同，这叫做构造方法的重载
使用方式：无论是否使用，都手动书写无参数构造方法和带参数构造方法
6.2.2构造方法的作用
6.3标准JavaBean类
1.类名需要见名知意
2.成员变量使用private修饰
3.提供至少两个构造方法
无参构造方法
带全部参数的构造方法
4.成员方法
提供每一个成员变量对应的setXxx（）/getXxx（）
如果还有其他行为，也需要写上
package Demo;
public class User {
//属性
private String userName;
private String password;
private String email;
private char gender;
private int age;
//get和set方法
// 快捷键：alt+insert/alt+fn+insert
//插件PTG 1秒生成标准JavaBean
//右键ptg to javabean
//空参
public User() {
}
public User(String userName, String password, String email, char gender, int age) {
this.userName = userName;
this.password = password;
this.email = email;
this.gender = gender;
this.age = age;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}6.4对象内存图
Java内存分配介绍
栈
堆
方法区
本地方法栈
寄存器
一个对象内存图
Student s=new Student()；
1.加载class文件
2.申明局部变量
3.在堆内存中开辟一个空间
4.默认初始化
5.显示初始化
6.构造方法初始化
两个对象的内存图
Student s1=new Student()；
Student s2=new Student()；
两个引用指向同一个对象
package Demo;
public class Student {
String name;
int age;
public void study(){
System.out.println("好好学习");
}
}
package Demo;
public class TestStudent {
public static void main(String[] args) {
Student stu1=new Student();
stu1.name="阿强";
//stu1，stu2指向同一个地址，将stu1的地址赋值给stu2
Student stu2=stu1;
stu2.name="阿珍";
System.out.println(stu1.name+" "+stu2.name);
}
}
6.5基本数据类型和引用数据类型
基本数据类型
数据值是存储在自己的空间中
特点：赋值给其他变量，也是赋的真实值
int a =10; //在栈里开辟了一个空间用来存储10
double b=20;
引用数据类型
数据值是存储在其他空间中，自己空间中存储的是地址值
Student s=new Student();//在堆里面开辟一个空间地址，用来存储s
int [ ]arr={1,2,3,4};//在堆里面开辟了一块空间用来存储数组元素
6.6this的内存原理
this的作用：区分局部变量和成员变量
this的本质：所在方法调用者的地址值
package Demo;
public class Student {
String name;
int age;
public void study(){
System.out.println("好好学习");
}
public void method(){
int age=10;
System.out.println(age);
System.out.println(this.age);//默认为成员变量的初始值0
}
}package Demo;
public class TestStudent {
public static void main(String[] args) {
Student s=new Student();
s.method();
}
}6.7综合训练
6.7.1文字版格斗游戏
格斗游戏，每个游戏角色的姓名，血量，都不相同，在选定人物的时候（new对象的时候），这些信息就应该被确定下来
角色1：
姓名：乔峰 血量：100
角色2：
姓名：鸠摩智 血量：100
javabean类：
package ultraExercise;
import java.util.Random;
import java.util.RandomAccess;
public class Role {
private String name;
private int blood;
public Role() {
}
public Role(String name, int blood) {
this.name = name;
this.blood = blood;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getBlood() {
return blood;
}
public void setBlood(int blood) {
this.blood = blood;
}
//定义一个方法用于攻击别人
//思考：谁攻击谁？
//方法的调用者去攻击参数
public void attack(Role role){
//造成的伤害是随机的1-20
Random r=new Random();
int hurt=r.nextInt(20)+1;
//修改一下挨揍的人的血量
//挨揍的角色剩余血量
int remainBlood=role.getBlood()-hurt;
//对剩余血量做一个验证，如果为负数，就修改为0
remainBlood=remainBlood<0?0:remainBlood;
//修改一下挨揍的人的血量
role.setBlood(remainBlood);
//this表示方法的调用者
System.out.println(this.getName()+"举起拳头，打了"+role.getName()+"一下+" +
"造成了"+hurt+"伤害，"+role.getName()+"还剩下了"+remainBlood+"血量");
}
}
测试类：
package ultraExercise;
public class GameTest {
public static void main(String[] args) {
//创建第一个角色
Role r1=new Role("乔峰",100);
//创建第二个角色
Role r2=new Role("鸠摩智",100);
//开始格斗，采取回合制游戏
while(true){
//r1开始攻击r2
r1.attack(r2);
//r2的剩余血量
if(r2.getBlood()==0){
System.out.println(r1.getName()+"K.O了"+r2.getName());
break;
}
//r2开始攻击r1
r2.attack(r1);
if(r1.getBlood()==0){
System.out.println(r2.getName()+"K.O了"+r1.getName());
break;
}
}
}
}
改良版
package ultraExercise;
import java.util.Random;
import java.util.RandomAccess;
public class Role {
private String name;
private int blood;
private char gender;
private String face;//长相随机
String[] boyface={"风流俊雅","气宇轩昂","相貌英俊","五官端正","相貌平平","一塌糊涂","面目狰狞"};
String[] girlface={"美奂绝伦","沉鱼落雁","婷婷玉立","身材姣好","相貌平平","相貌简陋","惨不忍睹"};
public Role(String name, int blood,char gender) {
this.name = name;
this.blood = blood;
this.gender=gender;
setFace(gender);
}
public Role(char gender) {
this.gender = gender;
}
public Role(String face) {
this.face = face;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public String getFace() {
return face;
}
public void setFace(char gender) {
Random r=new Random();
if(gender=='男'){
//从boyface里面随机长相
int index= r.nextInt(boyface.length);
this.face=boyface[index];
}else if(gender=='女'){
//从girlface里面随机长相
int index=r.nextInt(girlface.length);
this.face=girlface[index];
}else {
this.face = face;
}
}
public Role() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getBlood() {
return blood;
}
public void setBlood(int blood) {
this.blood = blood;
}
//定义一个方法用于攻击别人
//思考：谁攻击谁？
//方法的调用者去攻击参数
public void attack(Role role){
//造成的伤害是随机的1-20
Random r=new Random();
int hurt=r.nextInt(20)+1;
//修改一下挨揍的人的血量
//挨揍的角色剩余血量
int remainBlood=role.getBlood()-hurt;
//对剩余血量做一个验证，如果为负数，就修改为0
remainBlood=remainBlood<0?0:remainBlood;
//修改一下挨揍的人的血量
role.setBlood(remainBlood);
//this表示方法的调用者
System.out.println(this.getName()+"举起拳头，打了"+role.getName()+"一下+" +
"造成了"+hurt+"伤害，"+role.getName()+"还剩下了"+remainBlood+"血量");
}
public void showRoleInfo(){
System.out.println("姓名为："+getName());
System.out.println("血量为："+getBlood());
System.out.println("性别为："+getGender());
System.out.println("长相为："+getFace());
}
}
package ultraExercise;
public class GameTest {
public static void main(String[] args) {
//创建第一个角色
Role r1=new Role("乔峰",100,'男');
//创建第二个角色
Role r2=new Role("鸠摩智",100,'男');
//展示一下角色信息
r1.showRoleInfo();
r2.showRoleInfo();
//开始格斗，采取回合制游戏
while(true){
//r1开始攻击r2
r1.attack(r2);
//r2的剩余血量
if(r2.getBlood()==0){
System.out.println(r1.getName()+"K.O了"+r2.getName());
break;
}
//r2开始攻击r1
r2.attack(r1);
if(r1.getBlood()==0){
System.out.println(r2.getName()+"K.O了"+r1.getName());
break;
}
}
}
}
姓名为：乔峰
血量为：100
性别为：男
长相为：相貌平平
姓名为：鸠摩智
血量为：100
性别为：男
长相为：面目狰狞
乔峰举起拳头，打了鸠摩智一下+造成了11伤害，鸠摩智还剩下了89血量
鸠摩智举起拳头，打了乔峰一下+造成了11伤害，乔峰还剩下了89血量
乔峰举起拳头，打了鸠摩智一下+造成了17伤害，鸠摩智还剩下了72血量
鸠摩智举起拳头，打了乔峰一下+造成了11伤害，乔峰还剩下了78血量
乔峰举起拳头，打了鸠摩智一下+造成了17伤害，鸠摩智还剩下了55血量
鸠摩智举起拳头，打了乔峰一下+造成了3伤害，乔峰还剩下了75血量
乔峰举起拳头，打了鸠摩智一下+造成了2伤害，鸠摩智还剩下了53血量
鸠摩智举起拳头，打了乔峰一下+造成了15伤害，乔峰还剩下了60血量
乔峰举起拳头，打了鸠摩智一下+造成了15伤害，鸠摩智还剩下了38血量
鸠摩智举起拳头，打了乔峰一下+造成了8伤害，乔峰还剩下了52血量
乔峰举起拳头，打了鸠摩智一下+造成了13伤害，鸠摩智还剩下了25血量
鸠摩智举起拳头，打了乔峰一下+造成了14伤害，乔峰还剩下了38血量
乔峰举起拳头，打了鸠摩智一下+造成了16伤害，鸠摩智还剩下了9血量
鸠摩智举起拳头，打了乔峰一下+造成了14伤害，乔峰还剩下了24血量
乔峰举起拳头，打了鸠摩智一下+造成了19伤害，鸠摩智还剩下了0血量
乔峰K.O了鸠摩智6.7.2两个对象数组练习
定义数组存储3个商品对象
商品的属性：商品的id，名字，价格，库存
创建三个商品对象，并把商品对象存入到数组当中
package ultraExercise;
public class Goods {
private String id;
private String name;
private double price;
private int count;
public Goods() {
}
public Goods(String id, String name, double price, int count) {
this.id = id;
this.name = name;
this.price = price;
this.count = count;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}package ultraExercise;
public class GoodTest {
public static void main(String[] args) {
//创建一个数组
Goods[]arr=new Goods[3];
//创建三个商品对象
Goods g1=new Goods("001","华为mate60",5999,100);
Goods g2=new Goods("002","保温杯",299,500);
Goods g3=new Goods("003","枸杞",20,200);
//把商品添加到数组中
arr[0]=g1;
arr[1]=g2;
arr[2]=g3;
//遍历
for (int i = 0; i < arr.length; i++) {
Goods goods=arr[i];
System.out.println(goods.getId()+","+goods.getName()+","+goods.getPrice()+","+goods.getCount());
}
}
}
001,华为mate60,5999.0,100
002,保温杯,299.0,500
003,枸杞,20.0,200定义数组存储3部汽车对象
汽车的属性：品牌，价格，颜色
创建三个汽车对象，数据通过键盘录入而来，并把数据存入到数组中
package ultraExercise;
public class Cars {
private String band;
private int price;
private String color;
public Cars() {
}
public Cars(String band, int price, String color) {
this.band = band;
this.price = price;
this.color = color;
}
public String getBand() {
return band;
}
public void setBand(String band) {
this.band = band;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
package ultraExercise;
import java.util.Scanner;
public class CarTest {
public static void main(String[] args) {
//1.创建一个数组用来存3个汽车对象
Cars []arr=new Cars[3];
//2.创建汽车对象，数据来自键盘录入
Scanner sc=new Scanner(System.in);
for (int i = 0; i < arr.length; i++) {
//创建汽车对象
Cars c=new Cars();//对象一定要放在循环内部，这样就创建3个对象了
//录入品牌
System.out.println("请输入汽车的品牌");
String band=sc.next();
c.setBand(band);
//录入价格
System.out.println("请输入汽车的价格");
int price=sc.nextInt();
c.setPrice(price);
//录入颜色
System.out.println("请输入汽车的颜色");
String color=sc.next();
c.setColor(color);
//把汽车对象添加到数组当中
arr[i]=c;
}
//3.遍历数组
for (int i = 0; i < arr.length; i++) {
Cars cars = arr[i];
System.out.println(cars.getBand()+" ,"+cars.getPrice()+" ,"+cars.getColor());
}
}
}
键盘录入接收常见的细节问题
import java.util.Scanner;
public class CarTest {
public static void main(String[] args) {
//键盘录入两个体系不能混用
//弊端：先用nextInt,再用nextLine会导致下面的nextLine接受不到数据
//键盘录入
//第一套体系：
//nextInt();接收整数
//nextDouble;接收小数
//next();接收字符串
//遇到空格，制表符，回车就停止接收，这些符号后面的数据就不会接收了
//第二套体系
//nextLine();接收字符串
//可以接收空格，制表符，遇到回车才停止接收数据
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个字符串");
String line1=sc.nextLine();
System.out.println(line1);
System.out.println("请输入第二个字符串");
String line2=sc.nextLine();
System.out.println(line2);
}
}6.7.3构建一个商品类，并做判断
package ultraExercise;
public class Goods {
private int number;
private String name;
private double price;
private int count;
public Goods() {
}
public Goods(int number, String name, double price, int count) {
this.number = number;
this.name = name;
this.price = price;
this.count = count;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}
package ultraExercise;
import java.util.Scanner;
public class GoodsTest {
public static void main(String[] args) {
//创建一个对象用数组接受并进行存储
Goods []arr=new Goods[3];
Scanner sc=new Scanner(System.in);
for (int i = 0; i < arr.length; i++) {
Goods g=new Goods();
System.out.println("请输入第"+i+"件商品的编号");
int number=sc.nextInt();
g.setNumber(number);
System.out.println("请输入第"+i+"个商品的品牌");
String name=sc.next();
g.setName(name);
System.out.println("请输入第"+i+"个商品的价格");
double price=sc.nextInt();
g.setPrice(price);
System.out.println("请输入第"+i+"个商品的折扣");
int count=sc.nextInt();
g.setCount(count);
arr[i]=g;
}
for (int i = 0; i < arr.length; i++) {
Goods good=arr[i];
System.out.println(good.getNumber()+","+ good.getPrice()+","+good.getName()+","+good.getCount());
}
}
}
6.7.4复杂对象数组练习-添加和遍历-删除和修改
package ultraExercise;
public class Student {
private int id;
private String name;
private int age;
public Student() {
}
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}package ultraExercise;
public class StudentTest {
public static void main(String[] args) {
Student []arr=new Student[3];
Student stu1=new Student(001,"张三",23);
Student stu2=new Student(002,"李四",24);
Student stu3=new Student(003,"王五",25);
//把学生对象添加到数组中
arr[0]=stu1;
arr[1]=stu2;
arr[2]=stu3;
//再次添加一个学生对象，并在添加的时候进行学号的唯一判断
Student stu4=new Student(004,"赵六",26);
boolean flag=contains(arr,stu4.getId());
if(flag){
//已存在不用添加
System.out.println("当前id重复，请修改id后再进行添加");
}else {
//不存在可以把学生对象添加进数组
int count=getCount(arr);
if(count==arr.length){
//已存满
//创建一个新的数组，长度=旧数组长度+1
//把老数组的元素拷贝到新数组当中
Student[] newArr=createNewArr(arr);
newArr[count]=stu4;
//要求2:添加完毕后，遍历所有学生信息
printArr(newArr);
}else{
//没有存满
//[stu1,stu2,null]
//getCount获取到的是2，表示数组当中已经有了2个元素
//还有一层意思，如果下一次要添加数据，就是添加到2索引的位置
arr[count]=stu4;
//要求2:添加完毕后，遍历所有学生信息
printArr(arr);
}
}
//把stu4添加到数组中
//数组存满--只能创建一个新的数组，新数组长度=老数组+1
//找到id在数组中的索引
int index=getIndex(arr,2);
if(index>=0){
//如果存在则删除
arr[index]=null;
//要求4:删除完后进行遍历
printArr(arr);
}else {
//如果不存在则提示删除失败
System.out.println("当前id不存在删除失败");
}
//要求5:查询id为2的学生，如果存在将年龄+1
int target=getIndex(arr,2);
if(target>=0){
//存在将年龄+1岁
Student student = arr[index];
int age=student.getAge()+1;
student.setAge(age);
printArr(arr);
}else{
System.out.println("当前id不存在修改失败");
}
}
public static int getIndex(Student[]arr,int id){
for (int i = 0; i < arr.length; i++) {
Student stu=arr[i];
//对stu进行非空判断
if(stu!=null){
int sid=stu.getId();
if(sid==id){
return i;
}
}
}
//当循环结束后还没有找到
return -1;
}
public static void printArr(Student[]arr){
for (int i = 0; i < arr.length; i++) {
Student stu=arr[i];
if(stu!=null){
System.out.println(stu.getId()+", "+stu.getName()+", "+ stu.getAge());
}
}
}
public static Student[] createNewArr(Student[]arr){
Student []newArr=new Student[arr.length+1];
//循环遍历得到老数组中的每一个元素
for (int i = 0; i < arr.length; i++) {
newArr[i] =arr[i];
}
//把新数组返回
return newArr;
}
public static int getCount(Student []arr) {
//定义一个计数器用来统计
int count=0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] !=null) {
count++;
}
}
return count;
}
public static boolean contains(Student[]arr,int id){
for (int i = 0; i < arr.length; i++) {
Student stu=arr[i];
if(stu!=null) {
//获取数组中学生对象的id
int sid = stu.getId();
if (sid == id) {
return true;
}
}
}
//当循环结束后，还没有找到一样的，那么就表示数组中要查找的id是不存在的
return false;
}
}第七章字符串
7.1 API和API帮助文档
API（Application Programming Interface）:应用程序编程接口
简单理解：API就是别人已经写好的东西，我们不需要写直接使用即可
已经学过的API：
Scanner 键盘录入
Random 随机数
7.2 String 概述
字符串学习内容
String StringBuilder StringJonier
java.lang.String类代表字符串，java程序中的所有字符串文字（例如“abc”）都为此类的对象
String 的注意点
字符串的内容是不会发生改变的，它的对象在创建后不能被更改
创建String对象的两种方式
1.直接赋值--String name="尼古拉斯·赵四";
2.new--String s2=new String();
传递一个字符数组，根据字符数组的内容再创建一个新的字符串对象
char[ ] chs={'a','b','c'};
String s4=new String(chs);
传递一个字节数组，根据字节数组的内存再创建一个新的字符串对象
byte[ ] bytes={97,98,99,100};
String s5=new String(bytes);//abcd
把97，98，99，100对应的ASCII码值进行转换再输出
7.3 Java的常用方法（比较）
boolean equals方法（要比较的字符串） ：完全一样结果是true，否则为false
boolean equalslgnoreCase: 忽略大小写的比较
==号比的到底是什么？
基本数据类型比较的是数据值
int a=10;
int b=20;
sout(a==b);
引用数据类型比较的是地址值
String s1=new String("abc"）;
String s2=new String("bcd");
sout(s1==s2);//false
String s1=new String("abc");
//记录堆里面的地址值
String s2="abc";
//记录串池中的地址值
System.out.println(s1==s2);//false
String s1=new String("abc");
String s2="abc";
System.out.println(s1==s2);
boolean result1=s1.equals(s2);//比较两个字符串中的内容(大小写可忽略)
System.out.println(result1);
String s1=new String("abc");
String s2="Abc";
System.out.println(s1==s2);
boolean result1=s1.equalsIgnoreCase(s2);//比较两个字符串中的内容
System.out.println(result1);
//false
//true结论：只想要比较字符串的内容，就必须要用String里面的方法
7.4字符串练习
7.4.1用户登录
需求：已知正确的用户名和密码，请用程序实现模拟用户登录
总共给三次机会，登录之后，给出相应的提示
package String_Contest;
import java.util.Scanner;
public class test1 {
public static void main(String[] args) {
//定义两个变量记录正确的用户名和密码
String rightUsername="张三";
String rightPassword="123456";
//键盘录入用户名和密码
Scanner sc=new Scanner(System.in);
int count=0;
for(int i=0;i<3;i++) {
System.out.println("请输入用户名");
String username = sc.next();
System.out.println("请输入密码");
String password = sc.next();
count ++;
if (username.equals(rightUsername) && password.equals(rightPassword)) {
System.out.println("用户登录成功");
break;
} else {
System.out.println("用户登录失败，用户名或密码有误");
}
if(count==3){
System.out.println("对不起您输入的次数已达到3次，请停止输入");
}
}
}
}
7.4.2遍历字符串和统计字符个数
需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串
package String_Contest;
import java.util.Scanner;
public class test2 {
public static void main(String[] args) {
//键盘录入一个字符串进行遍历
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个字符串" );
String str = sc.next();
//字符串遍历快捷键 str.length.fori
for (int i = 0; i < str.length(); i++) {
//i表示字符串的每一个索引
char c = str.charAt(i);
System.out.println(c);
}
}
} 
/*统计该字符串大写字母字符，小写字母字符，数字字符出现的次数*/
package String_Contest;
import java.util.Scanner;
public class test3 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.nextLine();
int bigCount=0;
int smallCount=0;
int numberCount=0;
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if(c>='a'&& c<='z'){
//char类型的变量在参与计算的时候自动类型提升为int，查询ASCII码表
smallCount++;
} else if (c>='A'&& c<='Z') {
bigCount++;
}else if (c>='0'&& c<='9'){
//注意不能直接写0和9，要判断的是字符0和字符9
numberCount++;
}
}
//输出打印
System.out.println("小写字符一共有"+smallCount+"个");
System.out.println("大写字符一共有"+bigCount+"个");
System.out.println("数字字母有"+numberCount+"个");
}
} 
7.4.3字符串拼接和反转
定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果
例如：数组为int [ ]arr={1,2,3};
执行方法后的输出结果为：[1,2,3]
package String_Contest;
public class test4 {
public static void main(String[] args) {
int []arr={1,2,3};
String str=arrToString(arr);
System.out.println(str);
}
public static String arrToString(int []arr){
if(arr==null){
return "";
}
if(arr.length==0){
return "[]";
}
String result="[";
for (int i = 0; i < arr.length; i++) {
//进行判断2索引下的字符后不需要加","
if(i==arr.length-1){
result=result+arr[i];
}else {
result = result + arr[i] + ",";
}
}
return result+"]";
}
}
字符串反转
定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
例如：键盘录入abc，输出结果cba
package String_Contest;
import java.util.Scanner;
public class test5 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个字符串");
String str=sc.next();
String result=reverse( str);
System.out.println(result);
}
public static String reverse(String str){
String result="";
for (int i = str.length()-1; i >= 0; i--) {
//i表示字符串中的每个索引（倒序）
char c=str.charAt(i);
result=result+c;
}
return result;
}
}
7.4.4金额转换
2134----零佰零拾零万贰仟壹佰叁拾伍元
package String_Contest;
import java.util.Scanner;
public class exercise01 {
public static void main(String[] args) {
//键盘录入一个金额
Scanner sc=new Scanner(System.in);
int money;
while (true) {
System.out.println("请输入一个金额");
money=sc.nextInt();
if(money>=0&&money<=9999999){
break;
} else {
System.out.println("金额无效");
}
}
//2.定义一个字符串用来表示钱的大写
String moneyStr="";
//得到money里面每一位数字,再转成中文
while (true){
//从右往左获取数据，因为右侧是数据的个位
int ge=money%10;
String captialNumber = getCaptialNumber(ge);
moneyStr = getCaptialNumber(ge)+moneyStr;
money=money/10;
//如果数字上的每一位全部获取到，那么money记录的就是0，此时循环结束
if(money==0){
break;
}
}
//3.在前面补0，补齐7位
int count=7-moneyStr.length();
for (int i = 0; i < count; i++) {
moneyStr="零"+moneyStr;
}
System.out.println(moneyStr);
//4.插入单位
//定义一个数组表示单位
String [] arr={"佰","拾","万","仟","佰","拾","元"};
//遍历moneyStr,依次得到零零零贰壹叁伍
//然后把arr的单位插入进去
String result="";
for (int i = 0; i < moneyStr.length(); i++) {
char c=moneyStr.charAt(i);
//把大写数字和单位拼接到result当中
result=result+c+arr[i];
}
//5.打印最终结果
System.out.println(result);
}
//定义一个方法把数字变成大写的中文
//1--壹
public static String getCaptialNumber(int number){
String []arr={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
//返回结果
return arr[number];
}
}
7.4.5手机号屏蔽
131****9468
String substring(int beginIndex,int endIndex) 截取
注意点：包头不包围，包左不包右
只有返回值才是截取的小串
package String_Contest;
public class exercise02 {
public static void main(String[] args) {
//1.获取一个手机号码
String phoneNumber="13112349468";
//2.截取手机号前面的三位
String start=phoneNumber.substring(0,3);
System.out.println(start);
//3.截取手机号码后面四位
String end=phoneNumber.substring(7,11);
String result=start+"****"+end;
System.out.println(result);
}
}7.4.6身份证号码信息查看
1.2位：省份
3.4位：城市
5.6位：区县
7-14位：出生年月日
15.16：所在地派出所
17位：性别（奇数男性，偶数女性）
18位：个人信息码（随机）
package String_Contest;
public class exercise03 {
public static void main(String[] args) {
//1.定义一个字符串记录身份证号码
String id="321182202001011234";
//2.获取出生年月日
String year=id.substring(6,10);
String month=id.substring(10,12);
String day=id.substring(12,14);
System.out.println("人物信息为:");
System.out.println("出生年月日："+year+"年"+month+"月"+day+"日");
//3.获取性别
char gender=id.charAt(16);//'3'-->3
//利用ASCII码表进行转换
//'0'--->48
//'1'--->49
//'2'--->50
int num=gender-48;
if(num%2==0){
System.out.println("性别为:女");
}else {
System.out.println("性别为:男");
}
}
}
7.4.7游戏敏感词替换
String replace(旧值，新值)替换
注意点：只有返回值才是替换之后的结果
package String_Contest;
import java.util.Scanner;
public class exercise04 {
public static void main(String[] args) {
//1.获取到说的话
String talk="你玩的真好，以后不要再玩了,TMD";
//2.把里面的敏感词TMD替换为***
//String result=talk.replace("TMD","***");
//2.定义一个敏感词库
String []arr={"TMD","CNM","SB","MLGB"};
//3.循环得到数组中的每一个敏感词，依次进行替换
for (int i = 0; i < arr.length; i++) {
talk=talk.replace(arr[i],"***");
}
//4.打印结果
System.out.println(talk);
}
}7.5 StringBuilder
StringBuilder可以看成是一个容器，创建之后里面的内容是可变的
作用：提高字符串的操作效率
StringBuilder构造方法
public StringBuilder() 创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str) 根据字符串的内容，来创建可变字符串对象
StringBuilder常用方法
public StringBuilder append(任意类型) 添加数据，并返回对象本身
public StringBuilder reverse() 反转容器中的内容
public int length() 返回长度（字符出现的个数）
public String toString() 通过toString()就可以实现把StringBuilder转 换为String
package String_Contest;
public class instance1 {
public static void main(String[] args) {
StringBuilder sb=new StringBuilder("abc");
//添加元素
sb.append(1);
sb.append(2.3);
sb.append(true);
//反转
sb.reverse();
int len=sb.length();
System.out.println(len);
System.out.println(sb);
String string = sb.toString();
System.out.println(string);
}
}7.5.1对称字符串
需求：键盘接受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是
对称字符串：123321，111
非对称字符串：123123
package String_Contest;
import java.util.Scanner;
public class instance2 {
public static void main(String[] args) {
//键盘录入一个字符串
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个字符串");
String str= sc.next();
//反转键盘录入的字符串
/*StringBuilder sb=new StringBuilder();
sb.append(str);
sb.reverse();
System.out.println(sb);
*/
//反转键盘录入的字符串
String result=new StringBuilder().append(str).reverse().toString();
//比较
if(str.equals(result)){
System.out.println("当前字符串是对称字符串");
}else {
System.out.println("当前字符串不是对称字符串");
}
}
}
7.5.2拼接字符串
需求：定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回
调用该方法，并在控制台输出结果
例如：int [ ] arr={1,2,3};
执行方法后的结果为：[1,2,3]
package String_Contest;
import java.util.Scanner;
public class instance3 {
public static void main(String[] args) {
//定义数组
int []arr=new int[3];
Scanner sc=new Scanner(System.in);
System.out.println("请输入数组");
for (int i = 0; i < arr.length; i++) {
int str = sc.nextInt();
arr[i]=str;
}
String string = arrtoString(arr);
System.out.println(string);
}
public static String arrtoString(int[]arr) {
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
sb.append(arr[i]);
} else {
sb.append(arr[i]+", ");
}
}
sb.append("]");
return sb.toString();
}
}
7.6StringJoiner
StringJoiner跟StringBuilder一样，也可以看成是一个容器，创建之后里面的内容是可变的
作用：提高字符串的操作效率，代码编写简洁（很少用）
7.6.1构造方法&成员方法
public StringJoiner(间隔符号) 创建一个StringJoiner对象，指定拼接时的间隔符号
public StringJoiner(间隔符号，开始符号，结束符号) 创建一个StringJoiner对象，指定拼接 时的间隔符号，开始符号，结束符号
public StringJoiner add(添加内容) 添加数据，返回对象本身
public int length() 返回长度（字符出现的个数）
public String toString() 返回一个字符串
package StringInstance;
import java.util.StringJoiner;
public class exercise01 {
public static void main(String[] args) {
StringJoiner sj=new StringJoiner("---","[","]");
sj.add("aaa").add("bbb").add("ccc");
System.out.println(sj);
}
}
7.7字符串相关的底层原理
7.8字符串练习
7.8.1罗马数字的两种写法
package StringInstance;
import java.util.Scanner;
import java.util.StringJoiner;
public class exercise01 {
public static void main(String[] args) {
//1.键盘录入
Scanner sc=new Scanner(System.in);
String str;
while (true) {
System.out.println("键盘录入一个字符串");
str = sc.next();
//2.校验字符串是否满足规则
boolean flag=checkStr(str);
if(flag){
break;
}else {
System.out.println("当前字符串不符合规则请重新录入");
continue;
}
}
//将内容变成罗马数字
//查表法,数字跟数据产生一个对应关系
StringBuilder sb=new StringBuilder();
for (int i = 0; i < str.length(); i++) {
char c=str.charAt(i);
int number=c-'0';//12345
String s = changeLuoMa(number);
sb.append(s);
}
System.out.println(sb);
}
public static String changeLuoMa(int number){
//定义一个数组，让索引跟罗马数字产生一个对应关系
String []arr={"","Ⅰ","Ⅱ","Ⅲ","Ⅳ","Ⅴ","Ⅵ","Ⅶ","Ⅷ","v"};
return arr[number];
}
public static boolean checkStr(String str){
if(str.length()>9){
return false;
}
for (int i = 0; i < str.length(); i++) {
char c=str.charAt(i);//0-9
if(c<'0'||c>'9'){
return false;
}
}
return true;
}
}
7.8.2调整字符串的内容比较
package StringInstance;
public class exercise02 {
public static void main(String[] args) {
//定义两个字符串
String str1="abcdefg";
String str2="bcdefga";
//旋转字符串
str1=rotate(str1);
//循环旋转并比较
boolean result=check(str1,str2);
System.out.println(result);
}
public static boolean check(String str1,String str2){
for (int i = 0; i < str1.length(); i++) {
str1=rotate(str1);
if(str1.equals(str2)){
return true;
}
}
return false;
}
//旋转字符串，把左侧字符移动到右侧
public static String rotate(String str){
//有两种办法
//1.用subString进行截取，把左边的字符截取出来拼接到右侧去
//2.可以把字符串先变成一个字符数组，然后调整字符数组里面数据，最后再把字符数组变成字符串
char s = str.charAt(0);
String end = str.substring(1);
return end+s;
}
}
第八章ArrayList
集合与数组的区别：
集合可以随意扩容
8.1集合的基本使用
集合存储数据类型的特点
package ArrayList;
import java.util.ArrayList;
import java.util.Arrays;
public class Array02 {
public static void main(String[] args) {
//1.创建集合对象
//泛型:限定集合中存储数据的类型
ArrayList<String> list =new ArrayList<>();
//2.添加元素
list.add("aaa");
list.add("bbb");
list.add("ccc");
//3.删除元素
// String str=list.remove(1);
//4.修改元素
//list.set(1,"ddd");
//5.查询元素
// String s=list.get(0);
/*
System.out.println(s);
System.out.println(list);
*/
for (int i = 0; i < list.size(); i++) {
String str=list.get(i);
System.out.println(str);
}
}
}集合的遍历方式
需求：定义一个集合，添加字符串，进行遍历
遍历格式参照：[元素1，元素2，元素3]
package ArrayList;
import java.util.ArrayList;
public class Array03 {
public static void main(String[] args) {
//1.创建集合
ArrayList<String > list=new ArrayList<>();
//2.添加元素
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
//3.遍历
System.out.print("[");
for (int i = 0; i < list.size(); i++) {
if(i== list.size()-1){
System.out.print(list.get(i));
}else{
System.out.print(list.get(i)+",");
}
}
System.out.println("]");
}
}package ArrayList;
import java.util.ArrayList;
public class Array04 {
public static void main(String[] args) {
//1.创建集合
ArrayList<Integer> list=new ArrayList<>();
//2.添加元素
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
//3.遍历集合
System.out.print("[");
for (int i = 0; i < list.size(); i++) {
if(i==list.size()-1){
System.out.print(list.get(i));//最大索引只打印元素
}else {
System.out.print(list.get(i)+",");
}
}
System.out.print("]");
}
}
需求：定义一个集合，添加一些学生对象，进行遍历
学生类的属性为：姓名，年龄
package ArrayList;
public class Student {
private String name;
private int age;
private String sex;
public Student() {
}
public Student(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
package ArrayList;
import java.util.ArrayList;
public class Array05 {
public static void main(String[] args) {
//1.创建集合
ArrayList<Student> list=new ArrayList<>();
//2.创建学生对象
Student s1=new Student("张三",20,"男");
Student s2=new Student("李四",21,"男");
Student s3=new Student("王五",22,"男");
//3.添加元素（构建了Student类型的类，因此只能添加student类的属性）
list.add(s1);
list.add(s2);
list.add(s3);
for (int i = 0; i < list.size(); i++) {
//i索引list.get(i)元素/学生对象
Student student = list.get(i);
System.out.println(student.getName()+","+student.getAge()+","+student.getSex());
}
}
}
改良：键盘录入数据
package ArrayList;
import java.util.ArrayList;
import java.util.Scanner;
public class Array05 {
public static void main(String[] args) {
//创建集合,初始值长度为0
ArrayList<Student> list=new ArrayList<>();
//键盘录入学生信息并添加到集合当中
Scanner sc=new Scanner(System.in);
for (int i = 0; i < 3; i++) {
Student s=new Student();
//切不可把上一行代码放在循环外，放循环外则表明只创建一个对象。后面的键盘录入只是赋值
System.out.println("请输入学生的姓名");
String name=sc.next();
System.out.println("请输入学生的年龄");
int age=sc.nextInt();
System.out.println("请输入学生的性别");
String sex=sc.next();
//把name和age赋给学生对象
s.setName(name);
s.setAge(age);
s.setSex(sex);
//把学生对象添加到集合当中
list.add(s);
}
//遍历
System.out.println();
for (int i = 0; i < list.size(); i++) {
Student student = list.get(i);
System.out.println(student.getName()+","+student.getAge()+","+student.getSex());
}
}
}需求：
1.main方法中定义一个集合，存入三个用户对象
用户属性为：id ,username , password
2.要求：定义一个方法，根据id查找对应的用户信息
如果存在，返回true
如果不存在，返回false
import java.util.Scanner;
import java.util.SplittableRandom;
public class User_Array {
public static void main(String[] args) {
//创建集合
ArrayList<User> list=new ArrayList<>();
//键盘录入用户信息并添加到集合中
Scanner sc=new Scanner(System.in);
for (int i = 0; i < 3; i++) {
User user=new User();
System.out.println("请输入用户id");
String id = sc.next();
System.out.println("请输入用户的username");
String username = sc.next();
System.out.println("请输入用户的password");
String password = sc.next();
//把录入信息赋给用户对象
user.setId(id);
user.setUsername(username);
user.setPassword(password);
//把用户对象添加到集合中
list.add(user);
}
//调用方法查看id是否存在
contains(list,"002");
}
public static void contains(ArrayList<User>list,String id){
for (int i = 0; i < list.size(); i++) {
User u=list.get(i);
if(u.getId().equals(id)){
String result=u.getId()+u.getUsername()+u.getPassword();
System.out.println("找到用户了，它的个人信息为"+u.getId()+","+u.getUsername()+","+u.getPassword());
}
}
}
}8.2学生管理系统
第九章.面向对象进阶
9.1static-静态变量
需求：写一个JavaBean类来描述这个班级的学生
属性：姓名，年龄，性别
行为：学习
package Static_Object;
public class Student {
private String name;
private int age;
private String gender;
public static String teacherName;
public Student() {
}
public Student(String name, int age, String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
//行为
public void study(){
System.out.println("正在学习" );
}
public void show(){
System.out.println(name+","+age+","+gender+","+teacherName);
}
}
package Static_Object;
public class StudentTest {
public static void main(String[] args) {
Student s1=new Student();
s1.setName("张三");
s1.setAge(23);
s1.setGender("男");
Student.teacherName="阿伟";
s1.show();
s1.study();
Student s2=new Student();
s2.setName("翠花");
s2.setAge(22);
s2.setGender("女");
s2.show();
s2.study();
}
}
练习-定义数组工具类
package Static_Object;
public class ArrayUtil {
//私有化构造方法
//目的就是为了不让外界创建它的对象
private ArrayUtil(){}
//需要定义为静态的方便调用
public static String printArr(int []arr){
StringBuilder sb=new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
sb.append(arr[i]);
}else {
sb.append(arr[i]).append(", ");
}
}
sb.append("]");
return sb.toString();
}
public static double getAvg(double[]arr){
double sum=0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
return sum/ arr.length;
}
}
package Static_Object;
public class Test_ArrayUtil {
public static void main(String[] args) {
//测试工具类中的两个方法
int []arr1={1,2,3,4,5};
String s = ArrayUtil.printArr(arr1);
System.out.println(s);
double []arr2={1.1,2.2,3.3,4.4,5.5};
double avg = ArrayUtil.getAvg(arr2);
System.out.println(avg);
}
}
package Static_Object;
import java.util.ArrayList;
public class ArrayStudent {
private String name;
private int age;
private char gender;
public ArrayStudent() {
}
public ArrayStudent(String name, int age, char gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
}package Static_Object;
import java.util.ArrayList;
public class StudentUtil {
private StudentUtil(){}
//静态方法
public static int getMaxAge(ArrayList<ArrayStudent>list){
//找集合中的最大值
int max=list.get(0).getAge();//把集合里的0索引的学生对象的age赋给max
for (int i = 0; i < list.size(); i++) {
int temporaryAge=list.get(i).getAge();//用一个临时变量进行记录
if(max<temporaryAge){
max=temporaryAge;
}
}
return max;//循环结束之后返回max即可
}
}
package Static_Object;
import java.util.ArrayList;
public class Test_ArrayStudent {
public static void main(String[] args) {
//创建一个集合
ArrayList<ArrayStudent>list=new ArrayList<>();
ArrayStudent s1=new ArrayStudent("小明",21,'男');
ArrayStudent s2=new ArrayStudent("小红",20,'女');
ArrayStudent s3=new ArrayStudent("小华",23,'男');
list.add(s1);
list.add(s2);
list.add(s3);
//调用工具类中的方法
int maxAge = StudentUtil.getMaxAge(list);
System.out.println(maxAge);
}
}
static注意事项：
静态方法只能访问静态变量和静态方法
非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法
静态方法中没有this关键字
总结：静态方法中，只能访问静态。
非静态方法可以访问所有
静态方法中没有this关键字
9.2继承的概述
9.3继承的特点
Java只支持单继承，不支持多继承，但支持多层继承
多层继承：子类A可以继承父类B，父类B可以继承父类C
每一个类都直接或者间接的继承于Object
练习：
package extend;
public class Animal {
//权限修饰符：
//private：子类就无法访问
//私有：只能在本类中访问
public void eat(){
System.out.println("吃东西");
}
public void drinking(){
System.out.println("喝水");
}
}package extend;
public class cat extends Animal{
public void catchMouse(){
System.out.println("猫在抓老鼠");
}
}package extend;
public class dog extends Animal{
public void lookHome(){
System.out.println("狗看家");
}
}package extend;
public class Ragdoll extends cat{
}package extend;
public class LiHua extends cat{
}
package extend;
public class Husky extends dog{
public void breakHome(){
System.out.println("哈士奇在拆家");
}
}package extend;
public class Teddy extends dog{
public void touch(){
System.out.println("泰迪又在蹭腿了");
}
}package extend;
public class TestAnimal {
public static void main(String[] args) {
//创建布偶猫的对象
Ragdoll rd=new Ragdoll();
rd.eat();
rd.drinking();
rd.catchMouse();
//创建哈士奇的对象
Husky h=new Husky();
h.eat();
h.drinking();
h.lookHome();
h.breakHome();
}
}
权限修饰符：
private：子类就无法访问
私有：只能在本类中访问
注意事项：
子类只能访问父类中非私有的成员
构造方法是否可以被继承？构造方法不能被继承
package extend;
public class Fu {
String name="Fu";
}
package extend;
public class Zi extends Fu{
String name="Zi";
public void ziShow(){
String name="ZiShow";
System.out.println(name);//zishow
System.out.println(this.name);//Zi
System.out.println(super.name);//Fu,调用父类的成员变量
}
}package extend;
public class peopleTest {
public static void main(String[] args) {
Zi z=new Zi();
z.ziShow();
}
}
9.4方法重写
当父类的方法不能满足子类的需求时，需要进行方法重写
书写格式：在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法
@Override重写注释
1.@Override是放在重写后的方法上，校验子类重写时语法是否正确。
2.加上注解后如果有红色波浪线，表示语法错误
3.建议重写方法都加@Override注解，代码安全，优雅
package extend;
public class NewDog {
public void eat(){
System.out.println("狗吃狗粮");
}
public void drinking(){
System.out.println("狗喝水");
}
public void watchHome(){
System.out.println("狗看家");
}
}
class HashiQi extends NewDog{
//有一个额外的方法
public void breakHome(){
System.out.println("哈士奇又在拆家了");
}
}
class ShaPiDog extends NewDog {
//需要进行重写
//可以用到父类中的一种行为
@Override
public void eat() {
super.eat();
System.out.println("狗在吃骨头");
}
}
class ChineseDog extends NewDog{
//父类中的方法不能满足，需要进行重写
//用不到父类中方法的行为，不需要通过super进行调用
@Override
public void eat() {
System.out.println("狗吃剩饭");
}
}
package extend;
public class NewDogTest {
public static void main(String[] args) {
//创建对象
HashiQi hashiQi=new HashiQi();
hashiQi.eat();
hashiQi.drinking();
hashiQi.watchHome();
hashiQi.breakHome();
ShaPiDog shaPiDog=new ShaPiDog();
shaPiDog.eat();
shaPiDog.drinking();
shaPiDog.watchHome();
ChineseDog chineseDog=new ChineseDog();
chineseDog.eat();
chineseDog.drinking();
chineseDog.watchHome();
}
}9.5this，super关键字
父类：
package extend;
public class employee {
private int number;
private String name;
private int wage;
public employee() {
}
public employee(int number, String name, int wage) {
this.number = number;
this.name = name;
this.wage = wage;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getWage() {
return wage;
}
public void setWage(int wage) {
this.wage = wage;
}
public void work(){
System.out.println("员工在工作");
}
public void eat(){
System.out.println("员工在吃米饭");
}
}
子类:
package extend;
public class Manager extends employee {
private int bonus;
//空参构造
public Manager() {
}
//带全部参数的构造
//父类+子类
public Manager(int number, String name, int wage, int bonus) {
super(number, name, wage);
this.bonus = bonus;
}
public int getBonus() {
return bonus;
}
public void setBonus(int bonus) {
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("管理其他人");
}
@Override
public void eat() {
super.eat();
}
}
package extend;
public class chief extends employee {
//空参构造
public chief() {
}
//带全部参数的构造
public chief(int number, String name, int wage) {
super(number, name, wage);
}
@Override
public void work() {
System.out.println("厨师正在炒菜");
}
@Override
public void eat() {
super.eat();
}
}测试类：
package extend;
public class companyTest {
public static void main(String[] args) {
//创建对象并赋值调用
Manager manager=new Manager(001,"小华",5000,3000);
System.out.println(manager.getNumber()+","+manager.getName()+","+manager.getWage()+","+manager.getBonus());
manager.eat();
manager.work();
employee employee=new employee();
employee.setNumber(002);
employee.setName("王红");
employee.setWage(4000);
System.out.println(employee.getNumber()+","+employee.getName()+","+employee.getWage());
employee.eat();
employee.work();
chief c=new chief(002,"小光",5000);
System.out.println(c.getNumber()+","+c.getName()+","+c.getWage());
c.eat();
c.work();
}
}
9.6多态概述
package polymorphism;
public 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 name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void show(){
System.out.println(name+", "+age);
}
}
package polymorphism;
public class Student extends Person {
@Override
public void show() {
System.out.println("学生的信息为:"+getName()+", "+getAge());
}
}package polymorphism;
public class Teacher extends Person{
@Override
public void show() {
System.out.println("老师的信息为："+getName()+", "+getAge());
}
}package polymorphism;
public class Administrator extends Person{
@Override
public void show() {
System.out.println("管理员的信息为："+getName()+", "+getAge());
}
}
package polymorphism;
public class Test {
public static void main(String[] args) {
//创建三个对象并调用register方法
Student student=new Student();
student.setName("张三");
student.setAge(18);
Teacher teacher=new Teacher();
teacher.setName("王建国");
teacher.setAge(28);
Administrator administrator=new Administrator();
administrator.setName("管理员");
administrator.setAge(35);
register(student);
register(teacher);
register(administrator);
}
//这个方法既能接收老师，又能接收学生，管理员
//只能把参数写成这三个类型的父类
public static void register(Person p){
p.show();
}
}9.6.1多态调用成员的特点
package polymorphism;
public class Main {
public static void main(String[] args) {
//创建对象（多态方式）
//Fu f=new Zi;
Animal animal = new Dog();
//调用成员变量，编译看左边，运行也看左边
//编译看左边:javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败
//运行也看左边：java运行代码的时候，实际获取的就是左边父类中成员变量的值
System.out.println(animal.name);
//调用成员方法:编译看左边运行看右边
//编译看左边:javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败
//运行看右边:java运行代码的时候，实际上运行的是子类中的方法
animal.show();
//animal.eat(); 多态弊端，不能调用子类特有的功能，如：不能调用Dog的eat和lookHome方法
//解决方法
//变回子类类型就可以了
Dog dog=(Dog) animal;
dog.lookHome();
}
}
class Animal{
String name="动物";
public void show(){
System.out.println("Animal---show方法");
}
}
class Dog extends Animal{
String name="狗";
@Override
public void show() {
System.out.println("Dog---show方法");
}
public void eat(){
System.out.println("狗吃骨头");
}
public void lookHome(){
System.out.println("狗看家");
}
}
9.6.2多态练习
package polymorphism;
public class Nanimal {
private int age;
private String color;
public Nanimal(){
}
public Nanimal(int age, String color) {
this.age = age;
this.color = color;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void eat(String something){
System.out.println("动物在吃"+something);
}
}package polymorphism;
public class Ccat extends Nanimal{
public Ccat() {
}
public Ccat(int age, String color) {
super(age, color);
}
public void catchMouse(){
System.out.println("猫会抓老鼠");
}
@Override
public void eat(String something) {
System.out.println(getAge()+"岁的"+getColor()+"颜色的猫眯着眼睛侧着头吃"+something);
}
}
package polymorphism;
public class DDog extends Nanimal {
public DDog() {
}
public DDog(int age, String color) {
super(age, color);
}
@Override
public void eat(String something) {
System.out.println(getAge()+"岁的"+getColor()+"颜色的狗两只前腿死死的抱住"+something+"猛吃");
}
public void LookHome(){
System.out.println("狗会看家");
}
}package polymorphism;
public class Feedperson {
private String name;
private int age;
public Feedperson() {
}
public Feedperson(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
/*public void keepPet(DDog dDog,String something){
System.out.println("年龄为"+age+"岁的"+name+"养了一只"+dDog.getColor()+"颜色的"+dDog.getAge()+"岁的狗");
dDog.eat(something);
}
public void keepPet(Ccat ccat,String something){
System.out.println("年龄为"+age+"岁的"+name+"养了一只"+ccat.getColor()+"颜色的"+ccat.getAge()+"岁的猫");
ccat.eat(something);*/
//方法的形参:可以写这些类的父类，Animal
public void keepPet(Nanimal a,String something){
//做一个判断a是狗吗？
if(a instanceof DDog dDog){
System.out.println("年龄为"+age+"岁的"+name+"养了一只"+a.getColor()+"颜色的"+a.getAge()+"岁的动物");
dDog.eat(something);
}else if(a instanceof Ccat ccat){
System.out.println("年龄为"+age+"岁的"+name+"养了一只"+ccat.getColor()+"颜色的"+ccat.getAge()+"岁的动物");
ccat.eat(something);
}else {
System.out.println("没有这种动物");
}
}
}package polymorphism;
public class FeedTest {
public static void main(String[] args) {
Feedperson feedperson1=new Feedperson("老王",30);
DDog dDog=new DDog(2,"黑色");
feedperson1.keepPet(dDog,"骨头");
// Feedperson feedperson2=new Feedperson("老李",35);
Ccat ccat=new Ccat(3,"灰");
feedperson1.keepPet(ccat,"鱼");
Animal a=new Animal();
}
}9.7包和final
什么是包？
包就是文件夹。用来管理各种不同功能的java类，方便后期代码维护。
final
9.8权限修饰符
9.9抽象类和抽象方法
package oop_Abstract;
public abstract class Animal {
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
public void drink(){
System.out.println("动物在喝水");
}
}
package oop_Abstract;
public class frog extends Animal{
public frog() {
}
public frog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("青蛙在吃虫子");
}
}package oop_Abstract;
public class Test {
public static void main(String[] args) {
frog frog=new frog("小绿",1);
System.out.println(frog.getName()+","+frog.getAge());
frog.eat();
frog.drink();
}
}9.10接口
package interFace;
public abstract class animal {
private String name;
private int age;
public animal() {
}
public animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
}package interFace;
public class rabbit extends animal {
public rabbit() {
}
public rabbit(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("兔子在吃胡萝卜");
}
}package interFace;
public class Frog extends animal implements Swim{
public Frog() {
}
public Frog(String name, int age) {
super(name, age);
}
@Override
public void swim() {
System.out.println("青蛙在蛙泳");
}
@Override
public void eat() {
System.out.println("青蛙在吃虫子");
}
}package interFace;
public class dog extends animal implements Swim{
public dog() {
}
public dog(String name, int age) {
super(name, age);
}
@Override
public void swim() {
System.out.println("狗能狗刨");
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}package interFace;
public interface Swim {
public abstract void swim();
}package interFace;
public class test {
public static void main(String[] args) {
//创建对象
Frog frog=new Frog("小青",1);
System.out.println(frog.getName()+","+frog.getAge());
frog.eat();
frog.swim();
rabbit rabbit=new rabbit("小白",2);
System.out.println(rabbit.getName()+","+rabbit.getAge());
rabbit.eat();
dog dog=new dog("大黄",5);
System.out.println(dog.getName()+","+dog.getAge());
dog.eat();
dog.swim();
}
}
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
