JAVA零基础入门

HL计算机菜鸟

已于 2022-10-15 21:03:56 修改

阅读量550

点赞数

文章标签： java

于 2022-10-02 21:42:30 首次发布

本文链接：https://blog.csdn.net/m0_64390038/article/details/127146722

版权

//idea的步骤project moudle 创建个包包下java类

java开发包（JDK）
Java程序中最基本的组成单位是类。
类的·定义方式：
public class 类名{

}

main方法是程序的入口方法，程序的执行是从main方法开始的。
//固定格式
public static void main（String[] args）{

}
编写java程序的步骤
1新建java项目 2新建java类 3编写java代码 4运行程序

新建java项目 File/NEW/java project（java项目）设置项目名称—— （Finish）完成
Dont Creat（不创建）即可完成java项目

完成java项目新建后，可以在项目中创建java类右击src选择NEW(新建) /Class（类）

常用DOS环境命令
cmd 切换盘比如切换D盘 d: 回车就切换到d盘了
dir查看这个盘下所有的文件夹想进入哪个文件夹就cd 哪个文件夹名字
返回上一级文件就是cd ..
要想直接进入文件就是cd 文件\文件也就是二级目录直接进入
cd \直接回退到根目录
cls清屏命令
exit直接退出cmd窗口

Path环境变量的配置分为两步

1此电脑属性高级环境变量系统变量里面的新建变量名 JAVA_HOME
变量值浏览目录（我的是D盘jdk）确定
（也就是变量值赋给变量名编辑一下变量名（相当于添加）就能用了也就是相当于访问变量名就能访问变量值）

2 选中系统变量的里面的Path 点编辑之后弹出来窗口点新建之后输入%JAVA_HOME%\bin
然后依次点确定就配置完了

验证环境变量是否配置成功直接c盘 cmd 输入javac 看能不能出现许多行如果有东西就配置成功

在C语言里是main称之为主函数,是所有程序运行的入口

HelloWord输出在E盘（我自己在D盘建了一个的java文件）新建一个文本名字叫HelloWord.java
public class HelloWord {
public static void main(String[] args) {
System.out.println("Hello Word");
}
}
然后cmd 里面 javac HelloWord.java 这是编译回车（这里必须是文件名的名称）
java HelloWord 这是执行（这里执行不要扩展名.java）

控制台就会输出HelloWord

D:\jdk\bin>d:

D:\jdk\bin>cd\

D:\>cd java文件

D:\java文件>javac HelloWord.java

D:\java文件>javac HelloWord

注释单行注释 //注释信息多行注释/*注释信息*/
常量分类：字符型利用关键字char进行声明
字符串常量：用双引号括起来的内容"Hello Word"，"黑马程序员"
整数常量：不带小数的数字 666 -88
小数常量：带小数的数字 13.14 -5.21
字符常量：用单引号括起来的内容 'A','0','我'
布尔常量：布尔值表示真假 true ,false
空常量：一个特殊的值，空值，null

在为long型常量或变量赋值时，需要在所赋值的后面加一个字母L(或l)，说明所赋的值为long型
在为float型常量或变量赋值时，需要在所赋值的后面加一个字母F(或f)，说明所赋的值为float型

p18算术运算符
注意事项：
/和%的区别;两个数据做除法，/取结果的商，%取结果的余数
整数操作只能得到整数，要想得到小数，必须有浮点数参与运算
//定义两个变量
int a=6;
int b=4;
System.out.println(a+b);//10
System.out.println(a-b);//2
System.out.println(a*b);//24
System.out.println(a/b);//1
System.out.println(a%b);//2
//除法得到的是商，取余得到的是余数

//整数相除只能得到整数，要想得到小数必须有浮点数的参与
System.out.println(6.0/4);//1.5

p19字符的+操作
拿字符在计算机底层对应的数值来进行计算的
'A'-----65 A---Z是连续的
'a'-----97 a---z是连续的
'0'-----48 0-9是连续的

表达式中包含多个基本数据类型的值得时候，整个表达式的类型会自动提升
提升规则：
byte类型，short类型和char类型将被提升到int、类型
整个表达式的类型自动提升到表达式中最高等级操作数同样的类型
等级顺序：byte，short，char->int->long->float->double

/*int k=10+13.14;
//java语言默认小数为double型所以整个表达式类型提升为double型 k就不能用int声明应该是double
System.out.println(k);*/

p20字符串的+操作
（在+操作中如果出现了字符串就是连接运算符，否则就是算术运算符）
+号也就是连接符数字在前面先计算在连接
System.out.println("it"+"黑马");//+号连接符
System.out.println("黑马"+6+66);//输出黑马666
System.out.println(1+99+"黑马");//输出100黑马数字在前面先计算在连接
System.out.println(1.0+2.0+"黑马");//3.0黑马

P21赋值运算符
+=把左边和右边的数据做加法操作，结果赋值给左边
扩展的赋值运算符隐含了强制类型转换
++ 自增变量的值加1
-- 自减变量的值减1

参与操作使用
++i先执行加一在赋值
i++先赋值在自增1

//单独使用 i++；或者++i效果是一样的
= 一个是赋值
== 是判断相等
关系运算符的结果都是boolean类型要么是true，要么是false

p24逻辑运算符
&逻辑与运算符全真才为真有假则假
| 逻辑或运算符有真则真全假才假
∧逻辑异或运算符相同为假不同为真
！逻辑非运算符真变假假变真
int i=10;
int j=20;
int k=30;
System.out.println(!(i>j));//true

//&&和&
int i=10;
int j=20;
int k=30;

System.out.println((i++>100)&&(j++>100));//false也就是短路规则
//前面为假false 这个就不执行了(j++>100) 但是执行完i++ i自己自增1
System.out.println("i:"+i);//i:11
System.out.println("j:"+j);//j20

//&&和&区别
int i=10;
int j=20;
int k=30;

System.out.println((i++>100)&(j++>100));//判断完false程序i++ j++
还需要执行
System.out.println("i:"+i);//i:11
System.out.println("j:"+j);//j:21
注意事项：
逻辑与&无论左边真假，右边都要执行
短路&&，如果左边为真，右边执行，如果左边为假，右边不执行

逻辑或|，无论左边真假，右边都要执行
短路||如果左边为假，右边执行，如果左边为真，右边不执行

p26
三元运算符
格式关系表达式？表达式1：表达式2；例子a>b?a:b;
首先计算关系表达式的值如果是true表达式1的值就是运算结果
如果值为false，表达式2的值就是运算结果

例子：int a=10;
int b=20;
int max=a>b?a:b;
System.out.println("max:"+max);//结果：max：20

判断两个人体重是否相等
int weight1=180;
int weight2=200;
boolean b =weight1==weight2?true:false;
//因为运算结果返回的是布尔类型所以这里声明变量b就必须用boolean
System.out.println("b:"+b);//结果：b：false

p28三元运算符
比较三个谁的身高最高
int height1=150;
int height2=210;
int height3=165;
int t=height1>height2?height1:height2;
int max=height3>t?height3:t;
System.out.println("max:"+max);

p29数据输入
Scanner使用的基本步骤
1 导包 import java.util.Scanner;
(导包的动作必须出现在类定义的上边)
2 创建对象
Scanner sc=new Scanner(System.in);
(上面这个格式里面只有sc是变量名，可以变，其他的都不允许变)
3 接收数据
int i=sc.nextInt();
(上面这个格式里面只有i是变量名，可以变，其他的都不允许变)

键盘输入例子
import java.util.Scanner;
public class HelloWord {
public static void main(String[] args) {

Scanner sc=new Scanner(System.in);
int x=sc.nextInt();
System.out.println("x:"+x);

}
}

p30数据输入
键盘输入三个数字（这里比较的是身高），输出最大的数字
例子
import java.util.Scanner;
/*
*数据输入：
* 导包：
* import java.util.Scanner;
* 创建对象：
* Scanner sc=new Scanner(System.in);
* 接收数据：
* int x=sc.nextInt();
*
* */
public class demo30 {
public static void main(String[] args) {
//创建对象
Scanner sc=new Scanner(System.in);
//接收数据
//键盘录入三个身高分别赋值给三个变量
//键盘需要录入几个就写几个sc.nextInt();
System.out.println("请输入第一个人的身高：");
int height1=sc.nextInt();
System.out.println("请输入第二个人的身高：");
int height2=sc.nextInt();
System.out.println("请输入第三个人的身高：");
int height3=sc.nextInt();

int t=height1>height2?height1:height2;
int max=height3>t?height3:t;
//输出数据
System.out.println("这三个人中身高最高的的是:"+max+"cm");
}
}

p34奇偶数
例子:输入一个数字判断这个数字为奇数还是偶数
import java.util.Scanner;
public class demo34 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.print("请输入数字：");
int number=sc.nextInt();
if(number%2==0){
System.out.print("输入的数字"+number+"是偶数");
}else{
System.out.print("输入的数字为"+number+"是奇数");
}
}
}

p35 if else if语句
例子;
import java.util.Scanner;
public class demo35{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.print("请输入数字1-7：");
int week=sc.nextInt();
if(week==1){
System.out.println("星期一");
}else if(week==2){
System.out.println("星期二");
}else if(week==3){
System.out.println("星期三");
}else if(week==4){
System.out.println("星期四");
}else if(week==5){
System.out.println("星期五");
}else if(week==6){
System.out.println("星期六");
}else{
System.out.print("星期日");
}
}
}

p36if else if例子考试奖励
import java.util.Scanner;
public class demo36{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.print("请输入成绩：");
int score=sc.nextInt();
if(score>100||score<0){
System.out.println("你输入的成绩有误");
} else if(score>=95&&score<=100){
System.out.println("山地自行车一辆");
}else if(score>=90&&score<=94){
System.out.println("游乐场玩一次");
}else if(score>=80&&score<=89){
System.out.println("变形金玩具一个");
}else{
System.out.println("等着挨揍吧");
}
}
}

p37 switch 语句的使用
import java.util.Scanner;
public class demo37{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.print("请输入成绩：");

int week=sc.nextInt();
switch (week){
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;
default:
System.out.println("你输入的星期数有误");
break;//最后这个break写不写无所谓
}
}
}

p38 switch判断月份
import java.util.Scanner;
public class demo38{
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.print("请输入月份：");

int month=sc.nextInt();
switch (month){
case 1:
case 2:
case 12:
System.out.println("冬季");
break;
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
default:
System.out.println("你输入的月有误");
break;//最后这个break写不写无所谓
}
}
}

p41 1-5求和
public class demo39 {
public static void main(String[] args) {
int sum=0;
for (int i=1;i<=5;i++){
sum+=i;
}
System.out.println("1-5之间的数据和是"+sum);
}
}

p42 1-100之间的偶数求和
public class demo42 {
public static void main(String[] args) {
int sum=0;
for(int i=1;i<=100;i++) {
if (i%2==0) {
sum += i;
}
}
System.out.println("1-100的偶数和是"+sum);
}
}

p43 水仙花数是三位数它的个位十位百位的数字的立方和等于原数
// 水仙花数是三位数它的个位十位百位的数字的立方和等于原数
public class demo43 {
public static void main(String[] args) {
int count=0;//统计水仙花数有多少个
for(int i=100;i<1000;i++){
//在计算之前获取三位数中每个位上的值
int ge=i%10;//取个位
int shi=i/10%10;//取十位
int bai=i/10/10%10;//取百位
//判定条件是将三位数中每个数值取出来，计算立方和与原始数字比较是否相等
if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){
System.out.println("这个数是水仙花数"+i);
count++;
}
}
System.out.println("水仙花数有"+count+"个");
}
}

p45
public class demo45 {
public static void main(String[] args) {
//在控制台输出5次HelloWord
for(int i=1;i<=5;i++){
System.out.println("HelloWord");
}
System.out.println("-----------");

//while
int j=1;
while(j<=5){
System.out.println("HelloWord");
j++;
}
System.out.println("-----------");
//do while
/*do{
* 循环体语句；
* 条件控制语句；
* }while(条件判断语句);
*
* */
int x=1;
do{
System.out.println("HelloWord");
x++;
}while(x<=5);

}

p46 计算一张纸折叠多少次和珠穆朗玛峰一样高？
public class demo46 {
public static void main(String[] args) {
double papper=0.1;//纸张的厚度
int zf=8844430;//珠穆朗玛峰高度
int count=0;//计算折叠多少次

while(papper<=zf){
papper*=2;//折叠一次纸张的厚度要翻倍
count++;
}
System.out.println("折叠多少次"+count);
}
}

p49跳转控制语句
continue：用在循环中跳过循环体当前内容的执行继续下一次执行
break：用在循环中终止循环内容结束整个循环
public class demo49 {
public static void main(String[] args) {
for (int i=1;i<=5;i++){
if(i%2==0){
//continue;//continue是跳出本次循环,而不是终止整个循环 1 3 5
break;//break是终止整个循环 1
}
System.out.println(i);
}
}
}

p50循环嵌套
public class demo50 {
public static void main(String[] args) {
for(int hour=0;hour<3;hour++){
for (int minute=0;minute<4;minute++){
System.out.println(hour+"时"+minute+"分");
}
System.out.println("-----------");
}
}
}

结果：
0时0分
0时1分
0时2分
0时3分
-----------
1时0分
1时1分
1时2分
1时3分
-----------
2时0分
2时1分
2时2分
2时3分
-----------

p51Random 的作用和使用步骤
作用：用于产生一个随机数
1导包
import java.util.Random //导包的动作必须出现在类定义的上面
2创建对象
Random r=new Random（）；
//r是变量名，可以变其他都不允许变
3获取随机数
int number=r.nextInt（10）；//获取的范围[0,10)包括0，不包括10
//number是变量名可以变数字10可以变其他都不能变

例子
import java.util.Random;//用于产生一个随机数导包
public class demo51 {
public static void main(String[] args) {
Random r= new Random();//创建对象
//用循环获取10个随机数
for(int i=0;i<10;i++){
int number=r.nextInt(10);//获取随机数
//这里获取的是0-10之间的随机数包括0 但是不包括10
System.out.println("number:"+number);
}
System.out.println("--------");
//获取一个1-100之间的随机数
//给它加1就是0+1从1到101但是不包括101，也就是100
int x=r.nextInt(100)+1;
System.out.println(x);
}
}

p52猜数字游戏
------------------------------------------
import java.util.Random;
import java.util.Scanner;
public class demo52 {
public static void main(String[] args) {
//完成猜数字游戏首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
Random r=new Random(); //创建对象
int number=r.nextInt(100)+1;//获取随机数范围1到100
//System.out.println(number);//这是系统随机生成的数字
while(true){//不知道循环多少次就用while true死循环格式加个break
//使用程序实现猜数字，每次要输入猜测的数字值，需要使用键盘录入实现
Scanner sc=new Scanner(System.in);
System.out.println("请输入你要猜的数字");
int guessnumber=sc.nextInt();//接收数据

//比较输入的数字和系统产生的数据需要使用分支语句这里使用if else if格式根据不同情况进行猜测结果显示
if(guessnumber>number){
System.out.println("你猜的数字"+guessnumber+"大了");
}else if(guessnumber<number){
System.out.println("你猜的数字"+guessnumber+"小了");
}else {
System.out.println("恭喜你你猜对了");
break;
}

}

}
}

p54
IDEA中HelloWorld步骤
1 创建一个空项目（JavaSE_Code）
2 创建一个新模块（idea_test）
3 在idea_test模块下的src下创建一个包（com.itheima）
4 在com.itheima包下新建一个类（HelloWord）
5 在HelloWord类中编写代码
6 在idea中执行程序

idea结构
首先是项目
项目下可以有很多个模块
模块下面可以有很多个包
包下可以有很多个java文件

在视屏讲解中都是新建了很多模块

p56
idea设置字体 file Settings Editor Font Size 根据设置数字大小
Idea中内容辅助键和快捷键
快速生成语句
快速生成语句main（）方法psvm回车
快速生成输出语句：sout回车
内容辅助键
Ctrl+Alt+space(内容提示，代码补全等 space就是空格)
快捷键
注释单行：选中代码，Ctrl+/再来一次，就是取消
多行：选中代码，Ctrl+Shift+/再来一次，就是取消

格式化 Ctrl+Alt+L （内容美观）
导包 Alt+Enter
自动导包写一半回车
Ctrl+Alt+v可以直接生成左边也就是数据类型变量直接生成

p57 IDEA中模块操作
快速找到模块路径
右键模块 OPen in Explore 就找到了模块所在的目录

idea新建模块
File Project Structure Modules 点+号 New Module 选java （选择）jdk
Content root 最后idea_demo finish ok就完成了
idea删除模块
选择要删除的模块右键 Remove Module 点ok
但是他没有完全删除还在硬盘上，找到模块所在的目录右键删除才删除掉了
（可以点现有的模块，右键模块 OPen in Explore 就找到了模块所在的目录）
idea导入模块
把模块复制到项目目录下 File Project Stucture Moudles 点+号选择import moudle（引入模块）
找到需要导入的模块名称 ok next 一直点弹出窗体Overwrite finish 点击Setup SDK就可以了

P58数组定义格式
格式一数据类型[] 变量名
例子： int[] arr
定义了一个int类型的数组，数组名是arr

p59
java中的数组必须先初始化，然后才能使用
数组初始化方式
1动态初始化
2静态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值
格式;数据类型[] 变量名 = new 数据类型[数组长度]

控制台工具按钮 move to 可以调整控制台所在的位置
数组是从0开始的
数组在初始化时，会为存储空间添加默认值（new 后面这个数据类型）
整数：默认值0
浮点数：默认值0.0
布尔值：默认值false
字符:默认值是空字符
引用数据类型：默认值是null

例子：
int[] arr=new int[2];
int[] arr2=new int[3];
//分别输出数组名和元素
System.out.println(arr);//这个输出的是地址[I@14ae5a5
System.out.println(arr[0]);//整数：默认值0
System.out.println(arr[1]);//整数：默认值0

p64

package com.itheima_01;

public class ArrayTest03 {
public static void main(String[] args) {
//定义一个数组
int[] arr=new int[3];
arr[0]=100;
arr[1]=200;
arr[2]=300;
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

//定义第二个数组指向第一个数组
int[] arr2=arr;
arr2[0]=111;
arr2[1]=222;
arr2[2]=333;
//输出两个数组的名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr2);
System.out.println(arr2[0]);

}
}

结果：
[I@14ae5a5
100
200
300
[I@14ae5a5
111
[I@14ae5a5
111

p65：数组静态初始化
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度
格式：数据类型[] 变量名=new 数据类型[]{数据1，数据2，数据3........};
范例： int[] arr=new int[]{1,2,3};

简化格式：数据类型[] 变量名={数据1，数据2，数据3........};
范例： int[] arr={1,2,3};

例子：
package com.itheima_01;
//静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度
/*简化格式：数据类型[] 变量名={数据1，数据2，数据3........};
范例： int[] arr={1,2,3};*/
public class ArrayTest04 {
public static void main(String[] args) {
//定义数组
int[] arr={1,2,3};

//输出数组名
System.out.println(arr);

//输出数组中的元素
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}

结果：
[I@14ae5a5
1
2
3

p67 数组的遍历
获取数组元素数量
格式：数组名.length
范例：arr.length

例子：
package com.itheima_01;
public class ArrayTest01 {
public static void main(String[] args) {
//定义数组
int[] arr={11,22,33,44,55};
//使用通用遍历格式
for(int x=0;x< arr.length;x++){
System.out.println(arr[x]);
}

}
}

结果：
11
22
33
44
55

p68最大值
package com.itheima_01;
/*获取最值
获取数组中的最大值
*
* */
public class ArrayTest05 {
public static void main(String[] args) {
//定义数组
int[] arr={12,45,98,73,60};
//定义一个变量，用于保存最大值
//取数组中第一个数据作为变量的初始值
int max=arr[0];

//与数组中剩余的数据逐个对比，每次比对将最大值保存到变量中
for(int x=1;x< arr.length;x++){
if(arr[x]>max){
max=arr[x];
}
}
//循环结束后打印变量的值
System.out.println("max:"+max);
}
}

p69方法概述
什么是方法？
方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

注意:
方法必须先创建才可以使用，该过程称为方法定义
方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用

p70方法的定义和调用

方法定义
格式:
public static void 方法名(){
//方法体

}

范例 :
public static void isEvenNumber(){
//方法体
}

方法调用
格式: 方法名（）;
范例： isEvenNumber();
//调用必须在main里面调用，main方法是程序的入口方法，程序的执行是从main方法开始的。

注意：
方法必须先定义后调用，否则程序将报错

例子
package com.itheima_01;
/*什么是方法？
方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集*/

/*
方法定义
格式:
public static void 方法名(){
//方法体

}

方法调用
格式: 方法名（）;
*
* */
public class MethodDemo {
public static void main(String[] args) {
isEvenNumber();//方法调用
}

// 需求定义一个方法，在方法中定义一个变量，判断该数据是否是偶数
public static void isEvenNumber(){
//定义变量
int number=10;

//判断改数据是否是偶数
if(number%2==0){
System.out.println(true);
}else{
System.out.println(false);
}
}
}

P72方法练习
package com.itheima_01;
/*需求：
* 设计一个方法用于打印两个数中较大数
*
*思路：
* 1：定义一个方法，用于打印两个数字中较大数例如getMax()
* 2:方法定义两个变量，用于保存两个数字
* 3：使用分支语句两种情况对两个数字的大小进行处理
* 4：在main()方法中调用定义好的方法
* */
public class MethodTest {
public static void main(String[] args) {
getMax();
}

public static void getMax(){
int a=10;
int b=20;
//输出大数
if(a>b){
System.out.println(a);
}else{
System.out.println(b);
}

}
}

p73带参数方法定义和调用

带参数方法定义
格式： public static void 方法名(参数){........}

格式(单个参数)：public static void 方法名(数据类型变量名){........}
范例(单个参数)：public static void isEvenNumber(int number){..........}

格式(多个参数)： public static void 方法名(数据类型变量名1，数据类型变量名2，......){....}
范例(多个参数)： public static void getMax(int number1,int number2){..........}

注意：
方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
方法定义时，多个参数之间使用逗号(，)分割

带参数方法调用
格式：方法名（参数）；

格式(单个参数)：方法名（变量名/常量值）;
范例(单个参数)： isEvenNumber(5);

格式(多个参数): 方法名(变量名1/常量值1,变量名2/常量值2)；
范例(多个参数): getMax(5,6);

注意：
方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

例子：package com.itheima_01;

public class MethodTest02 {
public static void main(String[] args) {
//常量值的调用
isEvenNumber(10);

p74形参和实参
package com.itheima_01;
public class MethodTest02 {
public static void main(String[] args) {
//常量值的调用
isEvenNumber(10);

//变量的调用
int number=10;
isEvenNumber(number);
}
//需求：定义一个方法，该方法接受一个参数，判断该数据是否是偶数
public static void isEvenNumber(int number){
if(number%2==0){
System.out.println(true);
}else{
System.out.println(false);
}
}
}
形参：方法定义中的参数
等同于变量定义格式，例如：int number
实参：方法调用中的参数
等同于使用变量或常量，例如 10 number

p75 带参数方法练习
package com.itheima_01;
/*
* 需求：
* 设计一个方法用于打印两个数中的较大数，数据来自于参数
* 思路：
* 1：定义一个方法，用于打印两个数字中的较大数，例如getMax()
* 2:为方法定义两个参数，用于接收两个数字
* 3：使用分支语句两种情况对两个数字的大小进行处理
* 4：在main()方法中调用定义好的方法（使用常量）
* 5：在main()方法中调用定义好的方法（使用变量）
* */

public class MethodTestp75 {
public static void main(String[] args) {
//使用常量
getMax(10,20);
//使用变量
int a=20;
int b=30;
getMax(a,b);
}

public static void getMax(int a,int b){
if(a>b){
System.out.println(a);
}else{
System.out.println(b);
}
}
}

控制台输出
20
30

p76带返回值方法定义和调用

带返回值方法定义
格式 public static 数据类型方法名(参数){
return 数据;
}

范例1： public static boolean isEvenNumber(int number){
return true;
}

范例2： public static int getMax(int a,int b){
return 100;
}

注意：
方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错

带返回值方法调用
格式：数据类型变量名=方法名(参数)；
范例: boolean flag=isEvenNumber(5);

注意:
方法的返回值通常会使用变量接收，否则该返回值将无意义

例子：
public class MethodTestp76 {
public static void main(String[] args) {
// 数据类型变量名=方法名（参数）：
boolean flag=isEvenNumber(10);// 方法的返回值通常会使用变量接收，否则该返回值将无意义
System.out.println(flag);
}

//需求:定义一个方法，该方法接收一个参数，判断该数据是否是偶数，并返回真假值
public static boolean isEvenNumber(int number){
if(number%2==0){
return true;//方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
}else{
return false;//方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
}
}
}
控制台输出 true

***p77带返回值方法练习
package com.itheima_01;
//带返回值方法练习
* 需求：
* 设计一个方法可以获取两个数的较大值，数据来自于参数
* 思路：
* 1：定义一个方法，用于获取两个数字中较大数
* 2：使用分支语句分两种情况对两个数字的大小进行处理
* 3：根据题设分别设置两种情况下对应的返回结果
* 4：在main()方法中调用定义好的方法并使用变量保存
* 5：在main()方法中调用定义好的方法并直接打印结果
*
public class MethodTestp77 {
public static void main(String[] args) {
// 数据类型变量名=方法名（参数）：
int max=isEvenNumber(10,20);//方法的返回值通常会使用变量接收，否则该返回值将无意义
//因为返回的是int类型所以这里max也声明int类型接收
System.out.println(max);
//这样也能输出
System.out.println(isEvenNumber(10,20));
}

public static int isEvenNumber(int a,int b){
if(a>b){
return a;//方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
}else{
return b;//方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
}
}
}

控制台输出
20
20

P78方法的注意事项
方法不能嵌套定义
void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
return代表方法到这就已经结束了下面就不执行了

p79方法的通用格式
格式：public static 返回值类型方法名(参数){
方法体；
return 数据；
}

定义方法时，要做到两个明确
明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；
如果有，写对应的数据类型
明确参数：主要明确参数的类型和数量

返回值类型：方法操作完毕之后返回的数据的数据类型
如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return

return 如果方法操作完毕，有数据返回，用于把数据返回给调用者

调用方法时
void类型的方法，直接调用
非void类型的方法，推荐使用变量接收调用

p80方法重载
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同，类型不同或者数量不同

方法重载特点
重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，
换句话说不能通过返回值来判定两个方法是否相互成重载

例子：package com.itheima_01;
/*
方法重载：
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同，类型不同或者数量不同

与返回值无关
在调用的时候，java虚拟机会通过参数的同来区分同名的方法
* */
public class MethodTestp80 {
public static void main(String[] args) {
//调用方法
int result=sum(10,20);//方法的返回值通常会使用变量接收，否则该返回值将无意义
System.out.println(result);

double result2=sum(10.0,20.0);
System.out.println(result2);

int result3=sum(10,20,30);
System.out.println(result3);

}
//需求1：求两个int类型数据和的方法
public static int sum(int a,int b){
return a+b;
}
//需求2：求两个double类型数据和的方法
public static double sum(double a,double b){
return a+b;
}

//需求3：求三个int类型数据和的方法
public static int sum(int a,int b,int c){
return a+b+c;
}
}

控制台:
30
30.0
60

p81方法重载练习

package com.itheima_01;
/*方法重载练习
需求：使用方法重载的思想，设计比较两个整数是否是相同的方法，兼容全整数类型(byte,short,int,long)
思路：
1定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
2定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
3定义所有的重载方法，两个byte类型与两个short类型参数
4完成所有方法的调用，测试运行结果
* */
public class MethodTestp81 {
public static void main(String[] args) {
//调用方法
System.out.println(compare(10,20));//直接输出调用了

System.out.println(compare((byte)10,(byte)20));//(byte)强转成byte型
System.out.println(compare((short)10,(short)20));//(short)强转成short型
System.out.println(compare(10L,20L));//L强转long型
}

//int
public static boolean compare(int a,int b){
System.out.println("int");
return a==b;
}

//byte
public static boolean compare(byte a,byte b){
System.out.println("byte");
return a==b;
}

//short
public static boolean compare(short a,short b){
System.out.println("short");
return a==b;
}

//long
public static boolean compare(long a,long b){
System.out.println("long");
return a==b;
}

}

p82方法参数传递基本类型
package com.itheima_01;
/*方法参数传递
* 对于基本数据类型的参数，形式参数的改变，不影响实际参数的值
*/
public class MethodTestp82 {
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
调用change方法后:100

p83方法参数传递引用类型
package com.itheima_01;
//数组是引用类型
//对于引用类型的参数，形式参数的改变，影响实际参数的值
public class MethodTestp83 {
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;
}
}

控制台;
调用change方法前20
调用change方法后200

p84数组遍历
package com.itheima_01;
//数组遍历
/*需求;设计一个,方法用于数组遍历，要求遍历的结果是在一行上的。例如[11,22，33,44,55]
* 思路：
* 1因为要求结果在一行上输出，所以这里需要在学习上一个新的输出语句System.out.print("内容");
* System.out.println("内容");输出内容并换行
* System.out.print("内容");输出内容不换行
* System.out.println();起到换行的作用
* 2定义一个数组，用静态初始化完成数组元素初始化
* 3定义一个方法，用数组遍历通用格式对数组进行遍历
* 4用新的输出语句修改遍历操作
* 5调用遍历方法
*
* */

public class MethodTestp84 {
public static void main(String[] args) {
//定义一个数组，用静态初始化完成数组元素初始化
int[] arr={11,22,33,44,55};
//调用方法
printArray(arr);
}

public static void printArray(int[] arr){
System.out.print("[");
for(int x=0;x<arr.length;x++){
if(x== arr.length-1){
System.out.print(arr[x]);
}else{
System.out.print(arr[x]+",");
}
}
System.out.println("]");
}
}

p85数组最大值
package com.itheima_01;
/*
* 数组最大值
* 需求：设计一个方法用于获取数组元素中的最大值，调用方法并输出结果
*
* 思路：
* 1定义一个数组，用静态初始化完成数组元素初始化
* 2定义一个方法，获取数组中的最大值
* 3调用获取最大值方法，用变量接收返回结果
* 4吧结果输出在控制台上
*
*
* */
public class MethodTestp85 {
public static void main(String[] args) {
//定义一个数组用静态化初始化完成数组元素初始化
int[] arr={11,22,33,44,99};
//调用获取最大值方法，用变量接收返回结果
int max=getMax(arr);
//输出到控制台
System.out.println(max);
}

public static int getMax(int[] arr){
int max=arr[0];
for(int x=1;x<arr.length;x++){
if(arr[x]>max){
max=arr[x];
}
}
return max;
}
}

控制台:
99

p86 Debug
Debug概述
Debug：是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，
也可以用于追踪程序执行过程来调试程序

package com.itheima_03;
/*
* Debug：
* 是供程序员使用的程序调试工具，他可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序
* Debug调试，又被称为断点调试，断点其实是一个标记，告诉我们从哪里查看
*
* Debug操作流程：
* 1：如何加断点
* 2：如何运行加了断点的程序
* 3：看哪里
* 4：点哪里
* 5：如何删除断点
*
* 1.1选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可。
* 2.1在代码区域右键Debug执行
* 3.1看debug窗口看代码执行到哪里了，
* 4.1点上面箭头显示f7的向下执行，(或者向下执行) 点左边方块stop结束
* 5.1选择要删除的断点，单击鼠标左键即可如果是多个断点，可以每一个再点击一次，也可以一次性全部删除
* */
public class DebugDemo {
public static void main(String[] args) {
//定义两个变量
int i=10;
int j=20;

//求和
int sum=i+j;

//输出结果
System.out.println("sum:"+sum);
}
}

p89减肥计划if版
package com.itheima_04;

import java.util.Scanner;
/*
* 需求：输入星期数，显示今天的减肥活动
* 周一：跑步
* 周二：游泳
* 周三：慢走
* 周四：动感单车
周五：拳击
周六：爬山
周日：好好吃一顿
思路：
1键盘录入一个星期数，用一个变量接收
2对星期数进行判断，这里用if语句实现
3在对应的语句控制输出对应的减肥活动
导包:
* 1：手动导包 import java.util.Scanner;
2：快捷键导包 Alt+Enter
3：自动导包写一半回车
* */

public class Testp89 {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入星期数");
int week = sc.nextInt();
/* //对星期数进行判断，这里用if语句实现
if (week < 1 || week > 7) {
System.out.println("你输入的星期数有误");
} else if (week == 1) {
System.out.println("星期一跑步");
} else if (week == 2) {
System.out.println("星期二游泳");
} else if (week == 3) {
System.out.println("星期三慢走");
} else if (week == 4) {
System.out.println("星期四动感单车");
} else if (week == 5) {
System.out.println("星期五拳击");
} else if (week == 6) {
System.out.println("星期六爬山");
} else {
System.out.print("星期日好好吃一顿");
}
*/
switch(week){
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;
default:
System.out.println("您输入的星期数有误");
}
}

}

p91逢七过
package com.itheima_04;
/*
* 案例：逢七过
*
* 需求：从任意一个数字开始报数，当你要报的数字包含7或者7的倍数时都要说:过
* 为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足逢七必过原则的数据
* 这样，大家将来在玩游戏的时候，就知道那些数据要说过。
* 思路：
* 1数据在1-100之间用for循环实现数据的获取
* 2 根据规则用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
* x%10==7 x/10%10==7 x%7==0
*/
public class Testp91 {
public static void main(String[] args) {
//数据在1-100之间，用for循环实现数据的获取
for(int x=1;x<100;x++){
//根据规则用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
if(x%10==7 || x/10%10==7 || x%7==0){
System.out.println(x);
}
}
}
}

p92 不死神兔
package com.itheima_04;
/*
* 需求：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子
* 假如兔子都不死，问第十二个月的兔子对数为多少？
*
*找规律：
第一个月:1
第二个月:1
第三个月:2 老兔子生了一对
第四个月:3 老兔子又生了一对
第五个月:5 老兔子生了一对小兔子够了三个月也生了一对
数据连起来： 1 1 2 3 5

从第三个数据开始，每一个数据是前两个数据之和。
第一个和第二个数据是已知的

* 思路：
* 1为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
* 2因为第一个月，第二个月的对数是已知的，都是1，所以数组的第一个元素，第二个元素值也都是1
* 3用循环实现计算每个月的兔子对数
* 4输出数组中最后一个元素的值，就是第20个月的兔子对数。
*/
public class Testp92 {
public static void main(String[] args) {
//1为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
int[] arr=new int[20];
//2因为第一个月，第二个月的对数是已知的，都是1，所以数组的第一个元素，第二个元素值也都是1
arr[0]=1;
arr[1]=1;

/*从第三个数据开始，每一个数据是前两个数据之和。
第一个和第二个数据是已知的
arr[2]=arr[0]+arr[1];
arr[3]=arr[1]+arr[2];
arr[4]=arr[2]+arr[3];
*/
//3用循环实现计算每个月的兔子对数
for(int x=2;x< arr.length;x++){
arr[x]=arr[x-2]+arr[x-1];
}
//输出数组中最后一个元素的值，就是第20个月的兔子对数。
System.out.println("第二十个月的兔子对数是:"+arr[19]);
}
}

p93百钱百鸡

package com.itheima_04;

/*
* 需求：我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。
* 百钱买百鸡，问鸡翁，鸡母，鸡雏各几何？
*
* 公鸡5文钱一只小鸡一文钱三只母鸡3文钱一只
*思路：
* 1:第一层循环，用于表示鸡翁的范围，初始化表达式的变量定义为x=0，判断条件想x<=20
* 2:第二层循环，用于表示鸡母的范围，初始化表达式的变量定义为y=0，判断条件y<=33
* 3:这个时候用于表示鸡雏的变量z=100-x-y
* 4:判断表达式z%3==0和表达式5*x+3*y+z/3=100是否成立，如果成立输出对应的x,y,z的值
* 就是对应的鸡翁，鸡母，鸡雏的值
*
* */
public class Testp93 {
public static void main(String[] args) {
//1:第一层循环，用于表示鸡翁的范围，初始化表达式的变量定义为x=0，判断条件想x<=20
for (int x = 0; x <= 20; x++) {
//2:第二层循环，用于表示鸡母的范围，初始化表达式的变量定义为y=0，判断条件y<=33
for (int y = 0; y <= 33; y++) {
//3:这个时候用于表示鸡雏的变量z=100-x-y
int z = 100 - x - y;
// 4:判断表达式z%3==0和表达式5*x+3*y+z/3=100是否成立，如果成立输出对应的x,y,z的值
// 就是对应的鸡翁，鸡母，鸡雏的值
if (z % 3 == 0 && 5 * x + 3 * y + z / 3 == 100) {
System.out.println(x + "," + y + "," + z);
}
}
}
}
}

p94数组元素求和
package com.itheima_04;
/*
* 需求：有这样的一个数组，元素是{68.27.95.88.171.996.51.210}
* 求出该数组中满足要求的元素和，要求是：求和的元素个位和十位都不能是7，并且只能是偶数
*
*思路:
* 1定义一个数组，用静态初始化完成数组元素的初始化
* 2定义一个求和变量，初始值是0
* 3遍历数组，获取到数组中的每一个元素
* 4判断该元素是否满足条件，如果满足条件就累加
* arr[x]%10!=7 arr[x]/10%10!=7 arr[x]%2==0
* */
public class Testp94 {
public static void main(String[] args) {
int[] arr={68,27,95,88,171,996,51,210};
int sum=0;
for(int i=0;i< arr.length;i++){
int ge=arr[i]%10;//取个位
int shi=arr[i]/10%10;//取十位
if((ge!=7&&shi!=7)&&arr[i]%2==0){
sum+=arr[i];
}
}
System.out.println("sum:"+sum);
}
}

p95数字内容相同
package com.itheima_04;

/*
需求:设计一个方法，用于比较两个数组的内容是否相同

思路：
1定义两个数组，分别使用静态初始化完成数组元素的初始化
2定义一个方法,用于比较两个数组的内容是否相同
返回值类型:boolean
参数:int[] arr,int[] arr2
3比较两个数组的内容是否相同，按照下面的步骤实现就可以了
首先比较数组长度，如果长度不相同，数组内容肯定也不相同，返回false
其次遍历，比较两个数组中的每一个元素，只有元素不相同，返回false
最后循环遍历结束后，返回true
4调用方法，用变量接收
* */
public class Testp95 {
public static void main(String[] args) {
//定义两个数组，分别使用静态初始化完成数组元素的初始化
int[] arr = {11, 22, 33, 44, 55};
int[] arr2 = {11, 22, 33, 44, 55};
//调用方法，用变量接收
boolean flag = compare(arr, arr2);
//输出结果
System.out.println(flag);
}

//定义一个方法：用于比较两个数组的内容是否相同
/*
* 两个明确：
* 返回值类型:boolean
* 参数:int[] arr,int[] arr2
* */
public static boolean compare(int[] arr, int[] arr2) {
//首先比较数组长度，如果长度不相同，数组内容肯定也不相同，返回false
if (arr.length != arr2.length) {
return false;
}
// 其次遍历，比较两个数组中的每一个元素，只有元素不相同，返回false
//这里写arr 或者arr2都行，因为只有这两个长度相同，才会走到这里
for (int x = 0; x < arr.length; x++) {
if (arr[x] != arr2[x]) {
return false;
}
}
//最后循环遍历结束后,返回true
return true;

}

p96查找
package com.itheima_04;

import java.util.Scanner;

/*
* 查找
* 需求：已知一个数组arr[]={19,28,37,46,50};
* 键盘录入一个数据，查找该数据在数组中的索引，
* 并在控制台输出找到的索引值
*
* 思路;
* 1定义一个数组，用静态初始化完成数组元素的初始化
* 2键盘录入要查找的数据，用一个变量接收
* 3定义一个索引变量，初始值为-1
* 4遍历数组，获取到数组中的每一个元素
* 5拿键盘录入的数据和数组中的每一个元素进行比较，
* 如果值相同，就把该值对应的索引值赋值给索引变量并结束循环
*
* */
public class Testp96 {
public static void main(String[] args) {
int[] arr = {19, 28, 37, 46, 50};
//创建对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数据");
//接收数据
int number = sc.nextInt();
//定义一个索引变量，初始值为-1
int index = -1;

for (int x = 0; x < arr.length; x++) {
//拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同
//就把该值对应的索引赋值给索引变量并结束循环
if(arr[x]==number){
index=x;
break;
}
}
System.out.println("index:"+index);
}
}

***p97反转
package com.itheima_04;
/*
* 需求：已知一个数组arr={19,28,37,46,50};用程序实现把数组中的元素值交换
* 交换后的数组arr={50,46,37,28,19};并在控制台输出交换后的数组元素

* */
public class Testp97 {
public static void main(String[] args) {
int[] arr={19,28,37,46,50};

/* //循环遍历数组这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
//交换
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}*/
reverse(arr);
printArray(arr);
}

public static void reverse(int[] arr) {
//循环遍历数组这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
//交换
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}

public static void printArray(int[] arr){
System.out.print("[");
for(int x=0;x< arr.length;x++){
if(x== arr.length-1){
System.out.print(arr[x]);
}else{
System.out.print(arr[x]+",");
}

}
System.out.print("]");
}

}

P98评委打分
package com.itheima_04;

import java.util.Scanner;

/*
* 评委打分
* 需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分
* 选手的最后得分为：去掉一个最高分和一个最低分的4个评委平均值（不考虑小数部分）
*
* 思路:
* 1定义一个数组，用动态初始化完成数组元素的初始化，长度为6
* 2键盘录入评委分数
* 3由于是6个评委打分，所以接收评委分数的操作，用循环改进
* 4定义方法实现获取数组中的最高分(数组最大值)调用方法
* 5定义方法实现获取数组中的最低分(数组最小值)调用方法
* 6定义方法实现获取数组中的所有元素的和(数组元素求和)调用方法
* 7按照计算规则的到平均分
* 8输出平均分
* */
public class Testp98 {
public static void main(String[] args) {
int[] arr = new int[6];
System.out.println("请评委打分:");
//创建对象
Scanner sc = new Scanner(System.in);

//循环录入评委打分
for (int x = 0; x < arr.length; x++) {
System.out.println("请输入第" + (x + 1) + "个评委打分:");
arr[x] = sc.nextInt();
}
//定义方法实现获取数组中的最高分(数组最大值)调用方法
int max = getMax(arr);
//定义方法实现获取数组中的最低分(数组最小值)调用方法
int min = getMin(arr);
//定义方法实现获取数组中的所有元素的和(数组元素求和)调用方法
int sum=getSum(arr);

//按照计算规则的到平均分
int avg=(sum-max-min)/(arr.length-2);//arr.length-2也行==4
System.out.println("选手最终的分数是:"+avg);
}

//求最大值
public static int getMax(int[] arr) {
int max = arr[0];
for (int x = 1; x < arr.length; x++) {
if (arr[x] > max) {
max = arr[x];
}
}
return max;
}

//求最小值
public static int getMin(int[] arr) {
int min = arr[0];
for (int x = 1; x < arr.length; x++) {
if (arr[x] < min) {
min = arr[x];
}
}
return min;
}

//所有元素的和
public static int getSum(int[] arr){
int sum = 0;
for (int x = 0; x < arr.length; x++) {
sum += arr[x];
}
return sum;
}

}

p99类和对象
类：类是对现实生活中一类具有共同属性和行为的事物的抽象
对象：是能够看得到摸得着的真实存在的实体

类是对象的抽象
对象是类的实体

类的特点:
类是对象的数据类型
类是具有相同属性和行为的一组对象的集合

属性：对象具有各种特征，每个对象的每个属性都拥有特定的值
行为：对象能够执行的操作

p99类的定义
类的重要性：是java程序的基本组成单位
类的组成：属性和行为
属性：在类中通过成员变量来体现(类中方法外的变量)
行为：在类中通过成员方法来体现(和前面的方法相比去掉static关键字即可)
成员方法没有static

类的定义步骤：
1定义类
2编写类的成员变量
3编写类的成员方法

public class 类名{
//成员变量
变量1的数据类型变量1；
变量2的数据类型变量2;
.................
//成员方法
方法1
方法2
}

例子:
package com.itheima_05;
/*
* 类的定义
*
* 类的定义步骤：
* 定义类
* 编写类的成员变量
* 编写类的成员方法
* 手机类：
* 类名
* 手机(Phone)
*
* 成员变量:
* 品牌(brand)
* 价格(price)
*
* 成员方法：
* 打电话(call)
* 发短信(sendMessage)
* */
public class Phone {
//成员变量
String brand;//字符串类型的
int price;

//成员方法
public void call(){
System.out.println("打电话");
}

public void sendMessage(){
System.out.println("发短信");
}
}

p101对象的使用 //编写类的成员变量编写类的成员方法之后就使用叫对象的使用
*
创建对象
格式：类名对象名=new 类名();
范例: Phone p=new Phone();

使用对象
1：使用成员变量
格式：对象名.变量名
范例：p.brand

2:使用成员方法
格式:对象名.方法名()
范例: p.call()

package com.itheima_05;
import javax.swing.plaf.synth.SynthOptionPaneUI;
/*
* 创建对象
格式：类名对象名=new 类名();
范例: Phone p=new Phone();

使用对象
1：使用成员变量
格式：对象名.变量名
范例：p.brand
2:使用成员方法
格式:对象名.方法名()
范例: p.call()

* */
public class PhoneDemo {
public static void main(String[] args) {
//创建对象
Phone p=new Phone();

//使用成员变量
System.out.println(p.brand);
System.out.println(p.price);

p.brand="小米";
p.price=2999;

System.out.println(p.brand);
System.out.println(p.price);
//使用成员方法
p.call();
p.sendMessage();
}
}

p102学生
package com.itheima_05;
/*
* 需求：首先定义一个学生类，然后定义一个学生测试类
* 在学生测试类中通过对象完成成员变量和成员方法的使用
*
* 思路:
* 1,定义一个学生类
* 类名：Student
* 成员变量:name,age
* 成员方法:study(),doHomework()
* 2,定义学生测试类
* 类名:StudentDemo
* 因为要做测试，所以有一个主方法:main方法
* 3,在学生测试类中通过对象完成成员变量和成员方法的使用
* 给成员变量赋值,输出成员变量的值
* 调用成员方法
* */
public class Student {
//成员变量
String name;
int age;
//成员方法
public void study(){
System.out.println("好好学习，天天向上");
}
public void doHomeWork(){
System.out.println("键盘敲烂，月薪过万");
}
}

-------------------
package com.itheima_05;
/*学生测试类*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student p=new Student();

System.out.println(p.name+","+p.age);
//给成员变量赋值
p.name="黑马";
p.age=17;
//输出成员变量的值
System.out.println(p.name+","+p.age);
//调用成员方法
p.study();
p.doHomeWork();
}
}

---------
结果：
null,0
黑马,17
好好学习，天天向上
键盘敲烂，月薪过万

p105多个对象指向相同

package com.itheima_05;
/*
* 多个对象指向相同
* */
public class StudentTestp105 {
public static void main(String[] args) {
//创建对象
Student s1=new Student();
//使用成员变量
s1.name="林青霞";
s1.age=30;
System.out.println(s1.name+","+s1.age);

//把第一个对象的地址赋值给第二个对象
Student s2=s1;

s2.name="张曼玉";
s2.age=28;
System.out.println(s1.name+","+s1.age);
System.out.println(s2.name+","+s2.age);

}
}

控制台
林青霞,30
张曼玉,28
张曼玉,28

p106成员变量和局部变量
成员变量：类中方法外的变量
局部变量：方法中的变量（方法中形参的变量也是局部变量）

p107private关键字
封装
4.1private关键字
是一个权限修饰符
可以修饰成员(成员变量和成员方法)
作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问

针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
提供set变量名(参数)方法，用于设置成员变量的值，方法用public修饰 //这里变量名第一个字符要大写
提供get变量名()方法用于获取成员变量的值方法用public修饰

例子：
package com.itheima_06;
/*学生类*/
public class Student {
//成员变量
String name;
//int age;
private int age;

//提供get/set方法
public void setAge(int a){
//age=a;
if(a<0||a>120){
System.out.println("你给的年龄有误");
}else{
age=a;
}

}

public int getAge(){
return age;
}

//成员方法
public void show(){
System.out.println(name+","+age);
}
}
-------------------------------------------
package com.itheima_06;

public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s=new Student();

//给成员变量赋值
s.name="林青霞";
//s.age=30;
s.setAge(30);

//调用方法
s.show();
}
}

p108 private的使用

private关键字的使用
一个标准类的编写:
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法

----------------------------
package com.itheima_07;
/*学生类
* private关键字的使用
一个标准类的编写:
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
*
*
* */
public class Student {
//成员变量
private String name;
private int age;

//get/set方法
public void setName(String n){
name=n;
}

public String getName() {
return name;
}

public void setAge(int a){
age=a;
}

public int getAge(){
return age;
}
public void show(){
System.out.println(name+","+age);
}
}
----------------------------------
package com.itheima_07;

/*学生测试类*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();

//使用set方法给成员变量赋值
s.setName("卡卡西");
s.setAge(20);

s.show();
// 使用get方法获取成员变量的值
System.out.println(s.getName()+"--------"+s.getAge());

}
}

控制台：
卡卡西,20
卡卡西--------20
----------------------------------------------------
自我总结：一个private修饰的成员变量就需要对应一个set 和get 方法
---------------------------------------------------

p109this关键字
也就是局部变量和成员变量同名的时候，
为了怕局部变量把成员变量名字隐藏了
所以加this修饰，来解决局部变量隐藏成员变量问题
-----------------------------------------------------
自我总结：
用this修饰的指代的就是成员变量
//后面的name没有用this修饰指代的就是方法里的局部变量（也就是方法里的形参）
//也就是当写代码同名的情况用this说明一下
------------------------------------------
this修饰的变量用于指代成员变量
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

什么时候用this？解决局部变量隐藏成员变量

this：代表所在类的对象引用
记住：方法被哪个对象调用，this就代表哪个对象

----------------------------------------------------------
package com.itheima_08;
/*学生类
* 也就是局部变量和成员变量同名的时候，
为了怕局部变量把成员变量名字隐藏了
所以加this修饰，来解决局部变量隐藏成员变量问题
*
* */
public class Student {
private String name;
private int age;

/* public void setName(String n){
name=n;
}*/

public void setName(String name){
this.name=name;//用this修饰的指代的就是成员变量
//后面的name没有用this修饰指代的就是方法里的局部变量（也就是方法里的形参）
//也就是当写代码同名的情况用this说明一下
}

public String getName(){
return name;
}

/* public void setAge(int a){
age=a;
}*/

public void setAge(int age){
this.age=age;
}

public int getAge(){
return age;
}
public void show(){
System.out.println(name+","+age);
}
}
----------------------------------
package com.itheima_08;
/*测试学生类*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s=new Student();

//使用set方法给成员变量赋值
s.setName("林青霞");
s.setAge(30);

//调用show方法
s.show();

}
}
-----------
林青霞,30

P111封装
1，封装概述
是面向对象三大特征之一(封装，继承，多态)
是面向对象编程语言对客观世界的模拟，
客观世界里成员都是隐藏在对象内部的，外界是无法直接操作的

2，封装原则
将类的某些信息隐藏在类内部，不允许外部程序直接访问，
而是通过该类提供的方法来实现对隐藏信息的操作和访问
成员变量private，提供对应的getXxx()/setXxx()方法

3封装好处
通过方法来控制成员变量的操作，提高了代码的安全性
把代码方法进行封装，提高了代码的复用性

p112构造方法
构造方法是一种特殊的方法
作用:创建对象
格式:
public class 类名{
修饰符类名(参数){

}
}
功能：主要是完成对象数据的初始化
----------------------------------------
package com.itheima_p112;

/*学生类
构造方法:
作用：创建对象
功能：完成对象数据的初始化
格式：
修饰符类名(参数){

}
* 修饰符一般用：public
* */
public class Student {
private String name;
private int age;

//构造方法
public Student() {
System.out.println("无参构造方法");
}

public void show() {
System.out.println(name + "," + age);
}
}
-------------------
package com.itheima_p112;
/*测试类*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s=new Student();

s.show();
}
}
----------------------
控制台：
无参构造方法
null,0
----------------------------------
p113构造方法的注意事项
1构造方法的创建
如果没有定义构造方法，系统将给出一个默认的无参数构造方法
如果定义了构造方法，系统将不再提供默认的构造方法
2构造方法的重载
如果自定义了带构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法
3推荐的使用方式
无论是否使用，都手工书写无参数构造方法

例如：这就是无参数构造方法
public Student(){//这个()里面没有写参数

}
有参数构造方法
public Student(String name){//有参数构造方法，就是这个括号里写了String name有参数
this.name=name;
}

--------------------------------------------------------
例子：
package com.itheima_p113;
/*学生类*/
public class Student {
private String name;
private int age;

/* public Student(){
System.out.println("无参构造方法");
}*/

//一但给出构造方法系统将不再给出构造方法
//如果要是用就手动给出
public Student(){

}

public Student(String name){
this.name=name;
}

public Student(int age){
this.age=age;
}

//带多个参数的构造方法
public Student(String name,int age){
this.name=name;
this.age=age;
}

public void show(){
System.out.println(name+","+age);
}

}
-------------------------------------------
package com.itheima_p113;
/*测试类*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s=new Student();//这个就叫无参数构造方法
s.show();

//public Student(String name)
Student s2=new Student("林青霞");//有参数构造方法
s2.show();

//public Student(int age)
Student s3=new Student(30);//有参数构造方法
s3.show();

// public Student(String name,int age)
Student s4=new Student("林青霞",30);//有参数构造方法
s4.show();

}
}

---------------------------
控制台：
null,0
林青霞,0
null,30
林青霞,30
-------------------------
p114标准类制作
package com.itheima_p114;

/*标准类制作

1成员变量
使用private修饰
2构造方法
提供一个无参构造方法
提供一个带多个参数的构造方法
3成员方法
提供每一个成员变量对应的setXxx()/getXxx()
提供一个显示对象信息的show()
4创建对象并为其成员变量赋值的两种方式
无参构造方法创建对象后使用setXxx()赋值
使用带参构造方法直接创建带有属性值的对象
*
* */
public class Student {
//1,成员变量
private String name;
private int age;

//2,构造方法
//2,提供一个无参构造方法
public Student() {

}

//2,提供一个带多个参数的构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}

//3,提供每一个成员变量对应的setXxx()/getXxx()
public void setName(String name) {
this.name = name;
}

public String getName() {
return name;
}

public void setAge(int age) {
this.age = age;
}

public int getAge() {
return age;
}

//3, 提供一个显示对象信息的show
public void show() {
System.out.println(name + "," + age);
}

}
----------------------------------
package com.itheima_p114;

public class StudentDemo {
public static void main(String[] args) {
//4,创建对象并为其成员变量赋值的两种方式
//4无参构造方法创建对象后使用setXxx()赋值
Student s = new Student();
s.setName("卡卡西");
s.setAge(20);
s.show();

//使用带参构造方法直接创建带有属性值的对象
Student s2 = new Student("鸣人", 21);
s2.show();
}
}
---------------------
控制台：
卡卡西,20
鸣人,21
-------------------
p115API
API(Application Programming Interface):应用程序编程接口
编写一个机器人程序去控制机器人踢足球，程序需要向机器人发出向前跑，向后跑，射门，抢球等各种命令
机器人厂商一定会提供一些用于控制机器人的接口类，这些类中定义好了操作机器人各种动作的方法。
其实这些接口类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为API

Java API:指的就是JDK中提供的各种功能的Java类
这些类将底层的实现封装了起来，我们不需要关系这些类是如何实现的，
只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用

p116API的练习

package com.itheima_p116;

import java.util.Scanner;

/*
* Scanner:
* 用于获取键盘录入数据(基本数据类型，字符串数据)

public String nextline();
获取键盘录入字符串数据
* */
public class ScannerDemo {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入一个字符串数据:");
//接收数据
String line = sc.nextLine();//Ctrl+Alt+v可以直接生成左边
//输出结果
System.out.println("你输入的数据是:" + line);
}
}

p117String
String类在java.lang包下，所以使用的时候不需要导包
String类代表字符串，java程序中所有的字符串文字(例如"abc")都被实现为此类的实例
也就是说Java程序中所有的双引号字符串，都是String类的对象

字符串的特点
字符串不可变,它们的值在创建后不能被更改
虽然String的值是不可变的，但是它们可以被共享
字符串效果上相当于字符数组(char[]),但是底层原理是字节数组(byte[])

p118String构造方法
package com.itheima_118;

/*
* String构造方法:
* public String():创建一个空白字符串,不含有任何内容
* public String(char[] chs):根据字符数组的内容，来创建字符串对象
* public String(byte[] bys):根据字节数组的内容，来创建字符串对象
* String s="abc"; 直接赋值的方式创建字符串对象，内容就是abc
*
* */
public class StringDemo {
public static void main(String[] args) {
// public String():创建一个空白字符串,不含有任何内容
String s1 = new String();//String类在java.lang包下，所以使用的时候不需要导包
System.out.println("s1:" + s1);

// public String(char[] chs):根据字符数组的内容，来创建字符串对象
char[] chs = {'a', 'b', 'c'};
String s2 = new String(chs);
System.out.println("s2:" + s2);

// public String(byte[] bys):根据字节数组的内容，来创建字符串对象
byte[] bys = {97, 98, 99};//这里会把数字转化成对应的字母
String s3 = new String(bys);
System.out.println("s3:" + s3);
// String s="abc"; 直接赋值的方式创建字符串对象，内容就是abc
String s4 = "abc";
System.out.println("s4:" + s4);
}
}
-------------
控制台：
s1:
s2:abc
s3:abc
abc

p119String对象的特点
1通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址不同
char[] chs={'a','b','c'};
String s1=new String(chs);
String s2=new String(chs);
上面的代码中，JVM首先创建一个字符数组，然后每一次new的时候都会有一个新的地址，
只不过s1和s2参考的字符串内容是相同的

2 以""方式给出的字符串，只要字符序列相同(顺序和大小写)无论在程序代码出现几次
JVM都只会建立一个String对象，并在字符串池水
String s3="abc";
String s4="abc";
在上面代码中针对第一行代码，JVM会建立一个String对象放在字符串池中，并给s3参考
第二行则让s4直接参考字符串池中String对象，也就是说它们本质上时同一个对象
----------------------
package com.itheima_118;

public class StringTestp119 {
public static void main(String[] args) {
//构造方法的方式得到对象
char[] chs={'a','b','c'};
String s1=new String(chs);
String s2=new String(chs);
System.out.println(s1==s2);
//直接赋值的方式得到对象
String s3="abc";
String s4="abc";
System.out.println(s3==s4);
//比较字符串对象地址是否相同
System.out.println(s1==s3);
}

}
控制台
false
true
false

p120字符串比较
使用==做比较
基本类型：比较的是数据值是否相同
引用类型：比较的是地址是否相同

字符串是对象，他比较内容是否相同，是通过一个方法来实现的，这个方法叫equals()

public boolean equals(Object anObject):将此字符串与指定对象进行比较。
由于我们比较的是字符串对象，所以参数直接传递一个字符串
--------------------------------
package com.itheima_118;

/* 通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址不同
使用==做比较
基本类型:比较的是数据值是否相同
引用类型:比较的是地址值是否相同
*
字符串是对象，他比较内容是否相同，是通过一个方法来实现的，这个方法叫equals()
* public boolean equals(Object anObject):将此字符串与指定对象进行比较。
由于我们比较的是字符串对象，所以参数直接传递一个字符串
*
*
* */
public class StringDemo_p120 {
public static void main(String[] args) {
//构造方法的方式得到对象
char[] chs = {'a', 'b', 'c'};
String s1 = new String(chs);
String s2 = new String(chs);

//直接赋值的方式得到对象
String s3 = "abc";
String s4 = "abc";

//比较字符串对象地址是否相同
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s3 == s4);

//比较字符串内容是否相同
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s3.equals(s4));
}
}
--------
控制台
false
false
true
true
true
true

***p121用户登录
package com.itheima_p121;

import java.util.Scanner;

/*需求：已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登陆之后，给出相应的提示

思路:
1已知用户名和密码，定义两个字符串表示即可
2键盘录入要登录的用户名和密码，用Scanner实现
3拿键盘录入的用户名，密码和已知的用户名，密码进行比较，给出相应的提示。
字符串的内容比较用equals()方法实现
4用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候
使用break结束循环
* */
public class StringTestp121 {
public static void main(String[] args) {
//1已知用户名和密码，定义两个字符串表示即可
String username = "卡卡西";
int password = 123456;

for (int x = 0; x < 3; x++) {
//创建对象
Scanner sc = new Scanner(System.in);

System.out.println("请输入用户名:");
//接收数据
String name = sc.nextLine();

System.out.println("请输入用户密码:");
//接收数据
int mima = sc.nextInt();

boolean n = (username.equals(name));
boolean m = (password == mima);
if (n && m) {
System.out.println("登陆成功");
break;
} else {
if (2 - x == 0) {
System.out.println("你的账户被锁定请与管理员联系");
} else {
System.out.println("账号或密码错误你还有:" + (2 - x) + "次机会");
}
}

}
}
}
------------------
控制台：
请输入用户名:
1
请输入用户密码:
1
账号或密码错误你还有:2次机会
请输入用户名:
1
请输入用户密码:
1
账号或密码错误你还有:1次机会
请输入用户名:
1
请输入用户密码:
1
你的账户被锁定请与管理员联系

p122遍历字符串
package com.itheima_p121;

import java.util.Scanner;

/*遍历字符串
需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串

思路:
1键盘录入一个字符串，用Scanner实现
2遍历字符串，首先要能够获取到字符串中的每一个字符
public char charAt(int index):返回指定索引处的char值，
字符串的索引也是从0开始的
3遍历字符串，其次要能够获取到字符串的长度
public int length():返回字符串的长度
数组的长度:数组名.length
字符串的长度:字符串对象.length()
4遍历字符串的通用格式
for(int i=0;i<s.length();i++){
s.charAt(i);//就是指定索引处的字符值
}

* */
public class StringTestp122 {
public static void main(String[] args) {

//创建对象
Scanner sc=new Scanner(System.in);

//接收字符串
System.out.println("请输入字符串:");
String line=sc.nextLine();
// 数组的长度:数组名.length
//字符串的长度:字符串对象.length()
//循环输出字符串
// 字符串的索引也是从0开始的
for(int i=0;i<line.length();i++){
//能够获取到字符串中的每一个字符
System.out.println(line.charAt(i));
}
}
}
----------
控制台：
请输入字符串:
abcde
a
b
c
d
e

P123统计字符次数
package com.itheima_p121;

import java.util.Scanner;

/*案例：统计字符次数
需求:键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数
(不考虑其他字符)

思路：
1键盘录入一个字符串，用Scanner实现
2要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
3遍历字符串，得到每一个字符
4判断该字符属于哪种类型，然后对应类型的统计变量+1
假如ch是一个字符，我要判断它属于大写字母，小写字母，还是数字，直接帕努单该字符是否在对应的范围即可
大写字母：ch>='A'&&ch<='Z'
*
*
* */
public class StringTestp123 {
public static void main(String[] args) {
//创建对象
Scanner sc=new Scanner(System.in);
//接收字符串
System.out.println("请输入字符串:");
String line=sc.nextLine();
//定义大写字母
int uppercase=0;
//定义小写字母
int lowercase=0;
//定义数字
int number=0;

for(int i=0;i<line.length();i++){
//能够获取到字符串中的每一个字符
char c = line.charAt(i);
if(c>='A'&&c<='Z'){
uppercase++;
}else if(c>='a'&&c<='z'){
lowercase++;
}else{
number++;
}
}
System.out.println("大写字母有:"+ uppercase+"个");
System.out.println("小写字母有:"+lowercase+"个");
System.out.println("数字有:"+ number+"个");

}
}
控制台：
请输入字符串:
HLdxt123
大写字母有:2个
小写字母有:3个
数字有:3个

p124字符串拼接
package com.itheima_p121;
/*
* 案例：拼接字符串
*
* 需求:定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回，
* 调用该方法，并在控制台输出结果。
* 例如，数组为int[] arr={1,2,3};执行方法后的输出结果为：[1,2,3]
*
* 思路:
* 1定义一个int类型的数组，用静态初始化完成数组元素的初始化
* 2定义一个方法，用于把int数组中的数据按照指定格式拼接成一个字符串返回。返回值类型String
* 参数列表int[] arr
* 3在方法中遍历数组，按照要求进行拼接
* 4调用方法，用一个变量接收结果过
* 5输出结果
*
*
* */
public class StringTestp124 {
public static void main(String[] args) {
//定义一个数组，用静态初始化完成数组元素初始化
int[] arr={1,2,3};
//调用方法
String s = printArray(arr);
System.out.println(s);
}

public static String printArray(int[] arr){
String s="";
s+="[";
for (int x=0;x<arr.length;x++){
if(x==arr.length-1){
s+=arr[x];
}else {
s+=arr[x];
s+=", ";
}
}
s+="]";
return s;
}
}
控制台：
[1, 2, 3]

p125字符串反转
package com.itheima_p121;

import java.util.Scanner;

/*
* 案例：字符串反转
* 需求:定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
* 例如，键盘录入abc，输出结果cba
*
* 思路:
* 1键盘录入一个字符串，用Scanner实现
* 2定义一个方法，实现字符串反转。返回值类型String，参数String s
* 3在方法中把字符串倒着遍历，然后把每一个的到的字符拼接成一个字符串返回
* 4调用方法，用一个变量接收结果
* 5输出结果
*
*
*
*
*
* */
public class StringTest125 {
public static void main(String[] args) {
//创建对象
Scanner sc=new Scanner(System.in);
System.out.println("请输入字符串:");
String line=sc.nextLine();

//调用方法,用变量接收
String s= reverse(line);
System.out.println("s:"+s);
}

public static String reverse(String s) {
// 3在方法中把字符串倒着遍历，然后把每一个的到的字符拼接成一个字符串返回
//最终要拼成一个字符串,所以先定义一个字符串为空
String ss="";
for (int i=s.length()-1;i>=0;i--){
//能够获取到字符串中的每一个字符
ss+=s.charAt(i);
}
return ss;
}

}

-------------
endsWith()//测试此字符串是否以指定的内容结尾
---------

p127StringBuilder
如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，
又浪费内存空间而这种操作不可避免，那么有没有一种比较好的方式可以解决这个问题那？
答案是肯定的我们可以通过Java提供的StringBuilder类就来解决这个问题。

StringBuilder概述
StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器
这里的可变指的是StringBuilder对象中的内容是可变的

String和StringBuilder的区别
String：内容是不可变的
StringBuilder：内容是可变的

p128StringBuilder构造方法
package com.itheima_p128;
/*
* StringBuilder构造方法：
* public StringBuilder():创建一个空白可变字符串对象，不含有任何内容
* public StringBuilder(String str):根据字符串的内容来创建可变字符串对象
*
*StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器
这里的可变指的是StringBuilder对象中的内容是可变的
*
* */
public class StringBuilderDemo_p128 {
public static void main(String[] args) {
//public StringBuilder():创建一个空白可变字符串对象，不含有任何内容
StringBuilder sb=new StringBuilder();
System.out.println("sb:"+sb);
System.out.println("sb.length:"+sb.length());

// public StringBuilder(String str):根据字符串的内容来创建可变字符串对象
StringBuilder sb2=new StringBuilder("hello");
System.out.println("sb2:"+sb2);
System.out.println("sb2.length():"+sb2.length());
}
}

控制台：
sb:
sb.length:0
sb2:hello
sb2.length():5

p129 StringBuilder和String相互转换
package com.itheima_p129;
/*
*StringBuilder的添加和反转方法
* public StringBuilder append(任意类型)：添加数据，并返回对象本身
* public StringBuilder reverse():返回相反的字符序列
* */
public class StringBuilderDemo_p129 {
public static void main(String[] args) {
//创建对象
StringBuilder sb=new StringBuilder();

//public StringBuilder append(任意类型)：添加数据，并返回对象本身
/* StringBuilder sb2=sb.append("hello");
System.out.println("sb2:"+sb2);
System.out.println("sb:"+sb);*/

//链式编程添加数据，并返回对象本身既然是对象就可以继续调方法
sb.append("hello").append("world").append("java").append(100);
System.out.println("sb:"+sb);
//public StringBuilder reverse():返回相反的字符序列
sb.reverse();
System.out.println("sb:"+sb);
}
}

控制台：
sb:helloworldjava100
sb:001avajdlrowolleh

p130 StringBuilder和String相互转换
package com.itheima_p130;
/*
* StringBuilder和String相互转换
*
* 1，StringBuilder转换为String
* public String toString():通过toString()就可以把实现StringBuilder转换为String
*
* 2，String转换为StringBuilder
* public StringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder
*
*
* */
public class StringBuilderDemo_p130 {
public static void main(String[] args) {
/* StringBuilder sb=new StringBuilder();
sb.append("hello");//添加数据

//String s=sb;这个是错误的做法
//StringBuilder转换为String
//* public String toString():通过toString()就可以把实现StringBuilder转换为String
String s= sb.toString();
System.out.println(s);
*/

//String转换为StringBuilder 直接把String变量传进来就可以
String s="hello";
StringBuilder sb=new StringBuilder(s);
System.out.println(sb);

}
}

控制台：
hello

p131字符串拼接升级版
package com.itheima_p131;

/*
* 案例:拼接字符串
* 需求:定义一个方法，把int数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法
* 并在控制台输出结果。例如，数组为int[] arr={1,2,3};执行方法后输出结果为：
* [1,2,3]
*
* 思路：
* 1定义一个int类型的数组，用静态初始化完成数组元素的初始化
* 2定义一个方法，用于把int数组中的数据按照指定格式拼接成一个字符串返回
* 。返回值类型String，参数列表int[] arr
* 3在方法中用StringBuilder按照要求进行拼接，并把结果转成String返回
* 4调用方法，用一个变量接受结果
5输出结果
* */
public class StringBuilderDemo_p131 {
public static void main(String[] args) {
//1定义一个int类型的数组，用静态初始化完成数组元素的初始化
int[] arr = {1, 2, 3};
//调用方法
String s= arrayToString(arr);
System.out.println("s:"+s);
}

public static String arrayToString(int[] arr) {
//在方法中用StringBuilder按照要求进行拼接，并把结果转成String返回
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("]");
String s = sb.toString();//StringBuilder转换为String
return s;
}

}

p132字符串反转升级版
package com.itheima_p132;

import java.util.Scanner;

/*案例：字符串反转
* 需求：定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
* 例如,键盘录入abc，输出结果cba
*
* 思路：
* 1键盘录入一个字符串，用Scanner实现
* 2定义一个方法，实现字符串反转。返回值类型String参数String s
* 3在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
* 4调用方法，用一个变量接受结果
* 5输出结果
*
*
*
* */
public class StringBuilderDemo_p132 {
public static void main(String[] args) {
//创建对象
Scanner sc=new Scanner(System.in);
//接收数据
System.out.println("请输入字符串");
String s= sc.nextLine();
String line=reverse(s);
System.out.println("反转后的字符串:"+line);
}

public static String reverse(String s){
//在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
//String---StringBuilder--------reverse()--------String
//创建对象//String转换为StringBuilder 直接把String变量传进来就可以
StringBuilder sb=new StringBuilder(s);
sb.reverse();
//通过toString()就可以把实现StringBuilder转换为String
String ss=sb.toString();
return ss;
//这一行可以直接代表以代码
//先把字符串转换成StringBuilder类型在调用它的reverse()返回相反的字符序列，在通过toString()就可以把实现StringBuilder转换为String
//return new StringBuilder(s).reverse().toString();
}

}
---------
控制台：
请输入字符串
abc
反转后的字符串cba

p134 ArrayList
集合概述
集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变
ArrayList<E> 可调整大小的数组实现
<E>:是一种特殊的数据类型，泛型
----------------------------------
怎么用呢？在出现E的地方我们使用引用数据类型替换即可
举例ArrayList<String>,ArrayList<Student>

p135ArrayList构造和添加
package com.itheima_p135;

import java.util.ArrayList;
/*
* 集合概述
集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变
ArrayList<E> 可调整大小的数组实现
<E>:是一种特殊的数据类型，泛型
----------------------------------
怎么用呢？在出现E的地方我们使用引用数据类型替换即可
举例ArrayList<String>,ArrayList<Student>

* */
/*
* ArrayList构造方法:
* public ArrayList():创建一个空的集合对象
*
* ArrayList添加方法:
* public boolean add(E e):将指定的元素追加到此集合的末尾
* public void add(int index,E elemnt):在此集合中的指定位置插入指定的元素
* */
public class ArrayListDemo_p135 {
public static void main(String[] args) {
//public ArrayList():创建一个空的集合对象
//array是变量名后面<>不写是因为和前面一致可以简写
//ArrayList<String> array=new ArrayList<>();

ArrayList<String> array=new ArrayList<String>();

// public boolean add(E e):将指定的元素追加到此集合的末尾
// System.out.println(array.add("hello"));

array.add("hello");
array.add("world");
array.add("java");

//public void add(int index,E elemnt):在此集合中的指定位置插入指定的元素
array.add(1,"javase");

/*IndexOutOfBoundsException本来就4个元素但是从0开始 0 ，1 ，2 ，3，
这里写了个在5，插入4位置都没有所以 5报错了
array.add(5,"javase");
*/
//输出集合
System.out.println("array:"+array);

}
}
----------------
控制台
array:[hello, javase, world, java]

****p136ArrayList常用方法
package com.itheima_p135;

import java.util.ArrayList;

/*
* ArrayList常用方法:
* public boolean remove(object o):删除指定的元素，返回删除是否成功
* pubic E remove(int index):删除指定索引处的元素，返回被删除的元素
* public E set(int index,E element):被修改指定索引处的元素，返回被修改的元素
* public E get(int index):返回指定索引处的元素
* public int size():返回集合中的元素个数
* */
public class ArrayListDemo_p136 {
public static void main(String[] args) {
//创建集合
ArrayList<String> array=new ArrayList<String>();

//添加元素
array.add("hello");
array.add("world");
array.add("java");

//输出集合
System.out.println("array:"+array);

/* //删除指定的元素
array.remove("hello");
//输出集合
System.out.println("array:"+array);

//删除指定索引处的元素
array.remove(0);
//输出集合
System.out.println("array:"+array);

//public E set(int index,E element):被修改指定索引处的元素，返回被修改的元素
array.set(0,"javaee");
//输出集合
System.out.println("array:"+array);

//public E get(int index):返回指定索引处的元素
array.get(0);
//输出集合
System.out.println("array:"+array);

*/
//public int size():返回集合中的元素个数

System.out.println(array.size());
System.out.println("array:"+array);
}
}

------
控制台：
array:[hello, world, java]
3
array:[hello, world, java]

p137ArrayList存储字符串并遍历
package com.itheima_p135;

import java.util.ArrayList;

/*
* 需求：创建一个存储字符串的集合，存储3个字符串元素，使用程序实现在控制台遍历该集合
*
* 思路：
* 1创建集合对象
* 2往集合中添加字符串对象
* 3遍历集合，首先要能够获取到集合中的每一个元素，这个通过get(int index)方法实现
* 4遍历集合，其次要能够获取到集合的长度，这个通过size()方法实现
* 5遍历集合的通用格式
* for(int i=0;i<集合对象.size();i++){
* 集合对象.get(i)就是指定索引处的元素
* }
*
* */
public class ArrayListDemo_p137 {
public static void main(String[] args) {
//创建对象
ArrayList<String> array=new ArrayList<String>();
// 2往集合中添加字符串对象
array.add("卡卡西");
array.add("鸣人");
array.add("带土");

// 3遍历集合，首先要能够获取到集合中的每一个元素，这个通过get(int index)方法实现
for(int x=0;x< array.size();x++){
//public E get(int index):返回指定索引处的元素
String s = array.get(x);
System.out.println(s);
}

控制台：
卡卡西
鸣人
带土

}
}

p138ArrayList存储学生对象并遍历
package com.itheima_p138;
/*学生类*/
public class Student {
private String name;
private int age;

public Student(){

}

public Student(String name,int age){
this.name=name;
this.age=age;
}

public void setName(String name){
this.name=name;
}

public String getName(){
return name;
}

public void setAge(int age){
this.age=age;
}

public int getAge(){
return age;
}

}
----------------------------
package com.itheima_p138;

import java.util.ArrayList;

/*
* 需求:
* 创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
*
* 思路:
* 1定义学生类
* 2创建集合对象
* 3创建学生对象
* 4添加学生对象到集合中
* 5遍历集合，采用遍历格式实现
* */
public class ArrayListDemo_p138 {
public static void main(String[] args) {
//创建集合对象
ArrayList<Student> array=new ArrayList<Student>();

//创建学生对象
Student s1=new Student("林青霞",30);
Student s2=new Student("风清扬",33);
Student s3=new Student("张曼玉",18);

//添加学生对象到集合中
array.add(s1);
array.add(s2);
array.add(s3);

//遍历集合，采用遍历格式实现
for (int i=0;i< array.size();i++){
Student s = array.get(i);
System.out.println(s.getName()+","+s.getAge());
}
}
}
------
控制台：
林青霞,30
风清扬,33
张曼玉,18

P139ArrayList存储学生对象并遍历升级版package com.itheima_p139;

public class Student {
private String name;
private String age;

public Student(){

}

public Student(String name,String age){
this.name=name;
this.age=age;
}

public void setName(String name){
this.name=name;
}

public String getName(){
return name;
}

public void setage(String age){
this.age=age;
}

public String getAge(){
return age;
}
}
-------------------
package com.itheima_p139;

import java.util.ArrayList;
import java.util.Scanner;

/*案例：存储学生对象并遍历

需求:创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
学生的姓名和年龄来自于键盘录入
*
思路：
1定义学生类，为了键盘录入数据方便，把学生类中的成员变量都定义为String类型
2创建集合对象
3键盘录入学生对象所需要的数据
4创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
5往集合中添加学生对象
6遍历集合，采用通用遍历格式实现
* */
public class ArrayListDemo_p139 {
public static void main(String[] args) {
//创建集合对象
ArrayList<Student> array=new ArrayList<>();
//调用
addStudent(array);
addStudent(array);
addStudent(array);

//遍历集合，采用通用遍历格式实现
for (int i=0;i< array.size();i++){
Student s= array.get(i);//返回指定索引处的元素
System.out.println(s.getName()+","+s.getAge());
}
}

public static void addStudent(ArrayList<Student> array){
//创建对象
Scanner sc=new Scanner(System.in);
//接收数据
System.out.println("请输入学生姓名:");
String name= sc.nextLine();;

System.out.println("请输入学生年龄:");
String age= sc.nextLine();;

//创建学生对象
Student s=new Student();
//把键盘录入的数据赋值给学生对象的成员变量
s.setName(name);
s.setage(age);

//往集合中添加学生对象
array.add(s);
}

}
--------------
控制台
请输入学生姓名:
卡卡西
请输入学生年龄:
20
请输入学生姓名:
小明
请输入学生年龄:
20
请输入学生姓名:
小红
请输入学生年龄:
45
卡卡西,20
小明,20
小红,45
------------
P140学生管理系统项目演示
---------欢迎来到学生管理系统-------------
1添加学生
2删除学生
3修改学生
4查看所有学生
5退出
请输入你的选择：

p141学生管理系统之学生类
学生管理系统实现思路
1定义学生类
2主界面代码编写
3添加学生的代码编写
4查看学生的代码编写
5删除学生的代码编写
6修改学生的代码编写

package com.itheima_p140;

/*学生类*
Alt+Insert 根据自己的需要进行选择可以直接生成构造方法
或者get set方法按住shift全选
/
*/
/*学生类:
Student
成员变量:
学号:sid
* 姓名:name
年龄:age
居住地:address
*
* 构造方法:
无参构造
带四个参数的构造
* 成员方法：
每个成员变量对应给出get/set方法
* */
public class Student {
//学号
private String sid;
//姓名
private String name;
//年龄
private String age;
//居住地
private String address;

public Student(){

}

public Student(String sid,String name, String age,String address){
this.sid=sid;
this.name=name;
this.age=age;
this.address=address;

}

public void setSid(String sid){
this.sid=sid;
}

public String getSid(){
return sid;
}

public void setName(String name){
this.name=name;
}

public String getName(){
return name;
}

public void setAge(String age){
this.age=age;
}

public String getAge(){
return age;
}

public void setAddress(String address){
this.address=address;
}

public String getAddress(){
return address;
}

}
-------------------------

package com.itheima_p140;

import java.util.ArrayList;
import java.util.Scanner;

/*
* 学生管理系统
*
* */
public class StudentManager {
/*
1:用输出语句完成主界面的编写
2:用Scanner实现键盘录入数据
3:用switch语句完成操作的选择
4:用循环完成再次回到主界面
*/
public static void main(String[] args) {
//创建集合对象用于存储学生数据
ArrayList<Student> array=new ArrayList<Student>();
while (true){
//用输出语句完成主界面的编写
System.out.println("--------欢迎来到学生管理系统----------");
System.out.println("1 添加学生");
System.out.println("2 删除学生");
System.out.println("3 修改学生");
System.out.println("4 查看所有学生");
System.out.println("5 退出");
System.out.println("请输入你的选择");

//用Scanner实现键盘录入数据
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();

//用switch语句完成操作的选择
switch (line) {
//这里case 后面的1是字符串1，在jdk7后case 后面可以跟字符串了
case "1":
//System.out.println("添加学生");
addStudent(array);
break;
case "2":
//System.out.println("删除学生");
deleteStudent(array);
break;
case "3":
//System.out.println("修改学生");
updateStudent(array);
break;
case "4":
//System.out.println("查看所有学生");
findAllStudent(array);
break;
case "5":
System.out.println("谢谢使用");
System.exit(0);//为0 时正常退出程序
}

}

/*//定义一个方法，用于添加学生信息
public static void addStudent(ArrayList<Student> array) {
//键盘录入学生对象所需要的数据，显示提示信息，提示要输入何种信息
Scanner sc=new Scanner(System.in);
System.out.println("请输入学生学号：");
String sid=sc.nextLine();
System.out.println("请输入学生姓名：");
String name=sc.nextLine();
System.out.println("请输入学生年龄：");
String age=sc.nextLine();
System.out.println("请输入学生居住地：");
String address=sc.nextLine();

//创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
Student s=new Student();
s.setSid(sid);
s.setName(name);
s.setAge(age);
s.setAddress(address);

//将学生对象添加到集合中
array.add(s);

//给出添加成功提示
System.out.println("添加成功");

}
*/
//定义一个方法，用于添加学生信息
public static void addStudent(ArrayList<Student> array) {
//键盘录入学生对象所需要的数据，显示提示信息，提示要输入何种信息
Scanner sc=new Scanner(System.in);
//为了让sid在while循环外面被访问到，我们就把它定义在了循环外
String sid;
//为了让程序能够回都爱这里，我们是用循环实现
while (true) {
System.out.println("请输入学生学号：");
sid = sc.nextLine();

boolean flag = isUsed(array, sid);
if (flag) {
System.out.println("你输入的学号已经被使用，请重新输入");
}else{
break;
}
}
System.out.println("请输入学生姓名：");
String name=sc.nextLine();
System.out.println("请输入学生年龄：");
String age=sc.nextLine();
System.out.println("请输入学生居住地：");
String address=sc.nextLine();

//创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
Student s=new Student();
s.setSid(sid);
s.setName(name);
s.setAge(age);
s.setAddress(address);

//将学生对象添加到集合中
array.add(s);

//给出添加成功提示
System.out.println("添加成功");

}

//定义一个方法，判断学号是否被使用
public static boolean isUsed(ArrayList<Student> array,String sid){
//如果与集合中的某一个学生学号相同，返回true如果不相同返回false
boolean flag=false;

for(int i=0;i< array.size();i++){
Student s=array.get(i);
if (s.getSid().equals(sid)){
flag=true;
break;
}
}

return flag;
}

//定义一个方法，用于查看学生信息
public static void findAllStudent(ArrayList<Student> array) {
//判断集合中是否有数据，如果没有显示提示信息
if(array.size()==0){
System.out.println("无信息,请先添加信息在查询");
//为了让程序不在往下执行，给出return;
return;
}

//显示表头信息
//\t其实就是tab键
System.out.println("学号\t\t\t姓名\t\t年龄\t\t\t居住地");

//将集合中的数据取出按照对应格式显示学生信息，年龄显示补充"岁"

for (int i=0;i<array.size();i++){
Student s=array.get(i);
System.out.println(s.getSid()+"\t"+s.getName()+"\t"+s.getAge()+"岁\t\t"+s.getAddress());
}

}

//定义一个方法，用于删除学生信息
public static void deleteStudent(ArrayList<Student> array){
//键盘录入要删除的学生学号，显示提示信息
Scanner sc=new Scanner(System.in);

System.out.println("请输入你要删除的学生学号:");
String sid= sc.nextLine();

//在删除/修改学生操作前，对学号是否存在进行判断
//如果不存在，显示提示信息
//如果存在，执行删除/修改操作
int index=-1;
for(int i=0;i< array.size();i++){
Student s=array.get(i);
if(s.getSid().equals(sid)){
index=i;
break;
}
}
if(index==-1){
System.out.println("该信息不存在，请重新输入");
}else{
array.remove(index);//删除索引也就是集合的索引集合是可变的数组删除索引数据也就没了
//给出删除成功提示
System.out.println("删除学生成功");
}

}

//定义一个方法，用于修改学生信息
public static void updateStudent(ArrayList<Student> array) {
//键盘录入要修改的学生学号，显示提示信息
Scanner sc=new Scanner(System.in);
System.out.println("请输入要修改的学生学号:");
String sid= sc.nextLine();
//键盘录入要修改的学生信息
System.out.println("请输入学生新姓名");
String name= sc.nextLine();
System.out.println("请输入学生新年龄");
String age= sc.nextLine();
System.out.println("请输入学生新居住地");
String address= sc.nextLine();
//创建学生对象
Student s=new Student();
s.setSid(sid);
s.setName(name);
s.setAge(age);
s.setAddress(address);

for(int i=0;i< array.size();i++){
Student student = array.get(i);
if(student.getSid().equals(sid)){
array.set(i,s);
break;
}

}

//给出修改成功提示
System.out.println("修改学生成功");

}
}

P150继承
继承概述
继承是面向对象三大特征之一。可以使得子类具有父类的属性和方法，还可以在子类中重新定义
，追加属性和方法

继承的格式
格式：public class 子类名 extends 父类名{

}
范例:public class Zi extends Fu{

}

Fu:是父类，也被称为基类，超类
Zi:是子类，也被称为派生类

继承中子类的特点：
子类可以有父类的内容
子类还可以有自己特有的内容

p151继承的好处和弊端
继承好处
提高了代码的复用性(多个类相同的成员可以放到同一个类中)
提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

继承弊端
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化
削弱了子类的独立性

什么时候使用继承?
继承体现的关系：is a
假设法:我有两个类A和B,如果他们满足A是B的一种，或者B是A的一种
就说明他们存在继承关系，这个时候就可以考虑使用继承来体现，否则就不能滥用继承
举例：苹果和水果苹果是水果的一种所以可以设置水果为父类，苹果为子类
,猫和动物,
猫和狗就不行

p152继承中变量的访问特点

1在方法中使用变量的时候，首先要在方法内部中使用变量
2然后到本类中的成员位置去找
3如果本类中的成员位置也没有就会到父类成员位置去找

------
package com.itheima_p152;

public class Fu {
//年龄
public int age=40;
}
--------------
package com.itheima_p152;
/*
* 在子类中访问一个变量
* 子类局部范围找
* 子类成员范围找
* 父类成员范围找
* 如果没有就报错
* */
public class Zi extends Fu {
//身高
public int height=175;

//身高
public int age=20;

public void show(){
int age=30;
System.out.println(age);
System.out.println(height);
}
}
------------------------
package com.itheima_p152;
/*测试类*/
public class Demo {
public static void main(String[] args) {
//创建对象
Zi z=new Zi();
z.show();
}
}

-------------
p153super
----
package com.itheima_p153;
/*子类*/
public class Zi extends Fu{
public int age=20;

public void show(){
int age=30;
System.out.println(age);

//我要访问本类的成员变量age怎么办呢?
System.out.println(this.age);//this代表的是本类的成员变量的内容
//我要访问父类的成员变量age，怎么办呢？
System.out.println(super.age);//它可以访问父类的成员变量
}
}
-------------
package com.itheima_p153;
/*父类*/
public class Fu {
public int age=40;
}
---------------------
package com.itheima_p153;
/*测试类*/
public class Demo {
public static void main(String[] args) {
//创建对象，调用方法
Zi z=new Zi();
z.show();
}

}
------------------
控制台：
30
20
40
---------------
super关键字的用法和this关键字的用法相似
this：代表本类对象的引用
super：代表父类存储空间的标识(可以理解为父类对象引用)

--------------------------------------------------------------
***p154继承中构造方法的访问特点

子类中所有的构造方法默认都会访问父类中无参的构造方法

因为子类会继承父类中的数据，可能还会使用父类的数据。
所以子类初始化之前一定要先完成父类数据的初始化

每一个子类构造方法的第一条语句默认都是:super()

如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？
通过使用super关键字去显示的调用父类的带参构造方法
在父类中自己提供一个无参构造方法

推荐：自己给出无参构造方法
----------------------------------------------
p155继承中成员方法的访问特点

通过子对象访问一个方法
子类成员范围找
父类成员范围找
如果没有就报错

也就是先优先自己然后找父亲

-----------------------
package com.itheima_p155;

public class Fu {
public void show(){
System.out.println("Fu中show()方法被调用");
}
}
-----------------------------
package com.itheima_p155;

public class Zi extends Fu{

public void method(){
System.out.println("Zi中method()方法被调用");
}

public void show(){
super.show();//访问的是父类的成员方法
System.out.println("Zi中show()方法被调用");
}
}
---------------------------------
package com.itheima_p155;

public class Demo {
public static void main(String[] args) {
//创建对象，调用方法
Zi z=new Zi();
z.method();
z.show();
}
}
---------------------------------------
控制台：
Zi中method()方法被调用
Fu中show()方法被调用
Zi中show()方法被调用

p157方法重写
方法重写概述
子类中出现了和父类中一模一样的方法声明
方法重写的应用
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法
这样即沿袭了父类的功能，又定义了子类特有的内容

@Override这是注解可以为我们检查重写方法的方法声明的正确性
-----------------------------------------------------------
package com.itheima_p157;
/*手机类*/
public class Phone {
public void call(String name){
System.out.println("给"+name+"打电话");
}
}
----------------------------------------------
package com.itheima_p157;
/*新手机*/
public class NewPhone extends Phone{
@Override
public void call(String name){
System.out.println("开启视频功能");
// System.out.println("给"+name+"打电话");
super.call(name);

}
}
--------------------------------------------
package com.itheima_p157;
/*测试类*/
public class PhoneDemo {
public static void main(String[] args) {
//创建对象，调用方法
Phone p=new Phone();
p.call("林青霞");
System.out.println("---------------");

NewPhone np=new NewPhone();
np.call("林青霞");
}

}
---------------------------------
控制台：
给林青霞打电话
---------------
开启视频功能
给林青霞打电话
---------------------------------
p158方法重写注意事项

父类中的私有内容子类是不能继承到的

子类重写父类方法时，你的访问权限它只要不比父类低就可以了

私有方法不能被重写(父类私有成员子类是不能继承的)
子类方法访问权限不能更低(public>默认>private)
-----------------------------------------------------------
package com.itheima_p158;

public class Fu {
private void show(){
System.out.println("Fu中show()方法被调用");
}

void method(){//这里没有修饰符代表是默认的修饰符
System.out.println("Fu中method()方法被调用");
}
}
----------------------------------------------
package com.itheima_p158;

public class Zi extends Fu{
/* @Override
private void show(){
System.out.println("Zi中show()方法被调用");
}*/

@Override
void method(){//这里没有修饰符代表是默认的修饰符
System.out.println("Zi中method()方法被调用");
}
}
-------------------------------------------

p159 java中继承的注意事项

Java中类只支持单继承，不支持多继承
Java中类支持多层继承
------------------------------------
package com.itheima_p159;
/*爷爷类*/
public class Granddad {

public void drink(){
System.out.println("爷爷爱喝酒");
}
}
----------------------------------------
package com.itheima_p159;
/*父类*/
public class Father extends Granddad{

public void smoke(){
System.out.println("爸爸爱抽烟");
}
}
----------------------------------
package com.itheima_p159;
/*儿子类相当于父类继承了爷爷类儿子又继承了父类能用到爷爷类*/
public class Son extends Father{

}
--------------------------------------

****p160老师和学生
package com.itheima_p160_2;
/*父类*/
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;
}
}
----------------------------------
package com.itheima_p160_2;
/*老师类*/
public class Teacher extends Person {

//无参构造方法
public Teacher(){

}

public Teacher(String name,int age){
/*this.name=name;//他两个用不到父类的私有成员变量
this.age=age;*///他两个用不到父类的私有成员变量
super(name,age);//所以这里直接用super传过去父类就能用到
}

public void teach(){
System.out.println("用爱成就每一位学员");
}
}
------------------------
package com.itheima_p160_2;
/*测试类*/
public class PersonDemo {
public static void main(String[] args) {
//创建老师类对象并进行测试
Teacher t1=new Teacher();
t1.setName("林青霞");
t1.setAge(20);
System.out.println(t1.getName()+","+t1.getAge());
t1.teach();

//创建带参构造方法
Teacher t2=new Teacher("林青霞",30);
System.out.println(t2.getName()+","+t2.getAge());
t2.teach();
}
}
-------------
控制台：
林青霞,20
用爱成就每一位学员
林青霞,30
用爱成就每一位学员

---------------
p161猫和狗
package com.itheima_p161;
/*猫和狗公有的类
* 动物类
* */
public 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;
}
}
------------------------------------
package com.itheima_p161;
/*猫类*/
public class Cat extends Animal{
public Cat() {
}

public Cat(String name, int age) {
super(name, age);
}

public void catchMouse(){
System.out.println("猫抓老鼠");
}
}
-------------------------------------------
package com.itheima_p161;
/*测试类*/
public class AnimalDemo {
public static void main(String[] args) {
//创建猫类对象并进行测试
Cat c1=new Cat();
c1.setName("加菲猫");
c1.setAge(5);
System.out.println(c1.getName()+","+c1.getAge()+"岁");
c1.catchMouse();

//创建带参构造方法
Cat c2=new Cat("肥波",6);
System.out.println(c2.getName()+","+c2.getAge()+"岁");
c2.catchMouse();
}
}
-------------------------------------------------
控制台：
加菲猫,5岁
猫抓老鼠
肥波,6岁
猫抓老鼠
-----------------------

p162 package
包的概述和使用
为什么要建包？
包其实就是文件夹
因为包里面的类可能会出现同名情况建包每个类就在对应包里不然名字一样不好分类管理
包的作用：就是对类进行分类管理

包的定义格式
格式:package 包名；(多级包用.分开)
范例：package com.itheima；//很明显这是一个二级包 com是第一级包 itheima是二级包

带包的Java类编译和执行
手动建包:
按照以前的格式编译java文件 javac HelloWorld.java
手动创建包在E盘建立文件夹com然后在com下建立文件夹itheima
把class文件放到包的最里面把HelloWorld.class文件放到com下的itheima这个文件夹下
带包执行 java com.itheima.HelloWorld

自动建包:javac -d.HelloWorld.java java com.itheima.HelloWorld

p163导包
导包的格式
格式:import 包名;
范例:import cn.itcast.Teacher

p164 权限修饰符
-----------------------------------------------------------------------------------------------
修饰符同一个类中同一个包中不同包的子类不同包的无关类
子类无关类

private V

默认 V V

protected V V V

public V V V V
------------------------------------------------------------------------------------------------