第二周总结
程序员文章站
2024-01-29 13:52:16
...
第二周 第一天：
一.循环语句for，do-while：
1.do-while循环语句的格式
初始化语句;
do{
循环体语句;
步长语句
}while(条件表达式) ;
do-while循环语句和for,while循环的最大的区别就是:循环体至少执行一次(条件不满足的情况)
for,while,do-while循环
开发中:常用for循环,其次是while循环,do-while使用很少,以后在java源码中会见到这个语句!
2.for循环嵌套
for循环的嵌套:
for循环语句作为循环体语句;
for(初始化语句;条件表达式;步长语句){
//循环体语句
for(初始化语句;条件表达式;步长语句){
循环体语句;
}
}
例题：控制台输出:四行五列的*
*****
*****
*****
*****
*/
class ForForDemo{
public static void main(String[] args){
//最原始的做法:四个输出语句
System.out.println("*****") ;
System.out.println("*****") ;
System.out.println("*****") ;
System.out.println("*****") ;
System.out.println("------------------------") ;
//改进:每次输出一个*(去掉println()后面的ln),而且每次输出5个*完毕之后
//第一行
System.out.print("*") ;
System.out.print("*") ;
System.out.print("*") ;
System.out.print("*") ;
System.out.print("*") ;
//每次输出完5个*之后,换行
System.out.println() ;
//第二行:
System.out.print("*") ;
System.out.print("*") ;
System.out.print("*") ;
System.out.print("*") ;
System.out.print("*") ;
System.out.println() ;
//第三行:
System.out.print("*") ;
System.out.print("*") ;
System.out.print("*") ;
System.out.print("*") ;
System.out.print("*") ;
System.out.println() ;
//第四行:
System.out.print("*") ;
System.out.print("*") ;
System.out.print("*") ;
System.out.print("*") ;
System.out.print("*") ;
System.out.println() ;
System.out.println("----------------");
//问题:改进了,但是代码重复度高,继续改进:使用循环改进!
//输出里面的内容:有个*
//第一行:
for(int x = 0 ; x < 5; x ++) {//x=0,1,2,3,4
System.out.print("*");
}
System.out.println() ;
//第二行
for(int x = 0 ; x < 5; x ++) {//x=0,1,2,3,4
System.out.print("*");
}
System.out.println() ;
//第三行
for(int x = 0 ; x < 5; x ++) {//x=0,1,2,3,4
System.out.print("*");
}
System.out.println() ;
//第四行
for(int x = 0 ; x < 5; x ++) {//x=0,1,2,3,4
System.out.print("*");
}
System.out.println() ;
System.out.println("---------------------------");
//问题2:将单独输出的*,使用循环改进,发现代码依然很重复
//循环了四次,将上面的for循环在改进:
//x = 0,1,2,3
for(int x = 0 ; x < 4 ; x ++){ //外层循环控制行数
for(int y = 0 ; y < 5; y ++) {//y=0,1,2,3,4 内层循环在控制列数
System.out.print("*");
}
System.out.println() ;
}
}
}
二.跳转控制语句：
跳转控制语句:
break;
continue;
return ;
break :表示结束,中断的意思
break:单独使用,没有意义(存在问题),只能switch语句或者loop循环语句中使用!
如果while(true)和switch一块使用的时候,注意小细节:break此时只能结束switch语句,while(true)的结束,可以使用System.exit(0) ;
break应用场景:只能switch语句或者循环语句中使用!
情况1:中断结束单层循环
情况2:中断结束多层循环(早期使用)
什么标签语句:给外层或者内层循环起标签名称
标签名称:for(初始语句;条件表达式;步长语句){
标签名称:for(初始语句语句;条件表达式;步长语句){
循环体语句;
}
}
break 标签名称; 结束多层循环! (面试中:笔试题)
2.continue:继续 (结束当前循环,立即进入下一次循环)
单独使用:没有意义, continue 在 loop 外部(循环中使用)
for(int x =1 ; x <=10 ; x++){
if(x%3 == 0){
-----补全代码;
}
System.out.println("Java基础班") ;
}
3.return :一般很少单独使用,一般结束方法使用的
return是结合方法去使用的,如果一个方法中有return,具体返回结果;
三.方法：
1.方法的概念:
方法:就是使用{}包起来的内容,给{}独立的代码块起一个名字,以便于复用
--->定义一个方法
定义方法的格式
情况1:有具体返回值类型的方法定义
情况2:没有具体返回值类型的方法定义
有具体返回值类型的方法定义
权限修饰符 静态修饰符 返回值类型 方法名(数据类型1 变量名1,数据类型2 变量名2,......)
public static{
业务内容;
return 结果;
}
解释以上这个格式:
权限修饰符: public 公共的,公开的,访问权限最大的
静态修饰符: static (面向对象部分重点讲static关键字) 固定写法
返回值类型:数据类型(目前基本数据类型)
方法名:给{}代码块起一个名字,方法名要遵循"见名知意",(符合标识符的规则)
形式参数:
数据类型:数据类型(目前基本数类型)
变量名:要符合标识符的规则(起名字)
return:表示结束方法,调用方法的时候,给具体的返回结果; 如果没有return,报错!
定义完方法了,需要调用方法(目前调用方法是在main方法中调用)
单独调用: 无意义,没有输出结果
输出调用:(没有问题的,但是直接去使用了,不利于后期对该结果操作)
赋值调用:(推荐的)
2.定义方法以及调用方法的注意事项:
1)方法和方法是平级关系,不能再一个方法中定义另一个方法
2)在定义方法的时候,(目前来说),
必须带上static关键字(该方法目前都在main方法中调用,必须带上static)
3)在定义一个有返回值类型的方法的时候,知道两个明确
a)明确方法的返回值类型
b)明确参数类型以及参数个数
4)定义方法的时候,形式参数必须带上数据类型,否则报错(Java是一种强类型语言)
3没有具体返回值类型的方法定义以及调用
定义格式:
修饰符(public static) 返回值类型 方法名(参数类型1 变量名1,参数类型2 变量名2....){
要么输出结果要么相关其他业务功能 ,没有return关键字
}
Java中针对没有具体返回值类型的方法的定义,要遵循方法的格式,提供一个关键字void 来代替返回值类型
public static void 方法名(参数类型1 变量名1,参数类型2 变量名2....){
业务操作; 一般情况都是直接输出
}
四.数组:
数组的概念:
数组是一种"容器"
可以存储同一种类型的元素的一种"容器"
注意:
必须要保证该容器中存储的类型必须一致!
数组的定义:
数据类型[] 数组名称; 举例:int[] arr 定义了一个int数组的变量arr
数据类型 数组名称[] ; 举例:int arr[] 定义了一个int类型的变量arr数组
数组的初始化:
有两种初始化:
动态初始化:开发者定义数组初始化的时候,指定数组的长度,系统默认给数组中的元素赋值.
静态初始化:直接指定数组的元素内容,系统指定的数组长度
先使用数组的动态初始化:
数据类型[] 数组名称 = new 数据类型[数组长度] ;
数据类型 数组名称[] = new 数据类型[数组长度] ;
举例:
定义一个数组并且动态初始化
int[] arr = new int[3] ;
int arr[] = new int[3] ;
第二天：
1.数组异常：
1.数组中会遇见的一些异常:
异常:Throwable 类
异常分为两大类:
Error:程序出现了严重的问题;
Exception:
RuntimeException:运行时期异常
java.lang.ArrayIndexOutOfBoundsException属于运行时期异常的一种
java.lang.NullPointerException属于运行时期异常的一种
编译时期异常(只要不是RuntimeException的异常都属于编译时期)
java.lang.ArrayIndexOutOfBoundsException:属于运行时期异常的一种
数组角标越界异常
出现的原因:访问了数组中不存在的角标值
解决方案:更改角标在范围内即可!
java.lang.NullPointerException:空指针异常(引用类型中经常会出现的异常!)
出现的原因:
代码结构不严谨(某个对象已经为null,还有使用这个对象调用方法或者访问元素...)
解决方案:
只要 给对该对象进行非空判断
如果该对象不为空,才能使用这个对象完成一些操作!
arr = null ;
//加入一个逻辑判断:非空判断
if(arr!=null){
System.out.println(arr[0]) ;
}else{
System.out.println("该对象为空了,不能再使用这个对象了") ;
}
}
2.数组逆序排列：
//数组逆序查找法
class ArrayDemo1{
public static void main(String[] args){
int[] arr={12,34,32,67,54};
reserv(arr);
printArray(arr);
}
public static void reserv(int[] a){
for(int i = 0;i<a.length/2;i++){
int temp = a[i];
a[i] = a[a.length-1-i];
a[a.length-1-i]=temp;
}
}
public static void printArray(int[] arr1){
System.out.print("[");
for(int x=0;x<=arr1.length-1;x++){
if(x == arr1.length-1)
{
System.out.println(arr1[x]+"]");
}else{
System.out.print(arr1[x]+", ");
}
}
}
}
2.面试题：
数组中有没有length属性,字符串中有没有length属性,集合中有没有length属性
数组中:存在length属性
字符串没有length属性------->String类中:length()
集合中没有length属性------->集合中:size()
3.数组元素查找与基本查找：
1.
数组的基本查找法:(数组的元素内容可以无序)
从数组中的开始索引一直查询到末尾,查询出元素第一次在数组中的索引值；
2数组的元素查表法:
通过数组名称[角标值]确定内容
4.冒泡排序：
/*冒泡排序的思想:
两两比较,将较大的值往后放,第一次比较完毕,最大值出现在
最大索引处,依次这样比较...
规律:
两两比较,将较大的值往后放
总共比较的次数:数组长度-1次
*/
class MaoPao{
public static void main(String[] args){
int[] arr = {12,80,20,2,18,57,69};
System.out.println("排序后的顺序:");
bubble(arr);
printArray(arr);
}
public static void bubble(int[] a){
for(int i=0;i<a.length-1;i++){
for(int j=0;j<a.length-1-i;j++){
if(a[j]>a[j+1]){
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}
public static void printArray(int[] b){
System.out.print("[");
for(int x =0;x<b.length;x++){
if(x==b.length-1){
System.out.println(b[x]+"]");
}else{
System.out.print(b[x]+", ");
}
}
}
}
5.数组遍历与最值问题：
//数组最值与数组的遍历
class FindMax{
public static void main(String[] args){
int[] arr={20,52,54,52,50};
int max =getMax(arr);
System.out.println("max:"+max);
// printArray(arr);
}
public static int getMax(int[] array){
int max = array[0];
for(int i= 0;i<array.length-1;i++){
if(array[i]>array[i+1]){
max = array[i];
}else{
max = array[i+1];
}
}return max;
}
public static void printArray(int[] arr1){
System.out.print("[");
for(int x=0;x<=arr1.length-1;x++ ){
if(x==arr1.length-1){
System.out.println(arr1[x]+"]");
}else{
System.out.print(arr1[x]+", ");
}
}
}
}
6.二维数组：
二维数组:
其实就是一个元素为一维数组的数组
定义格式:
数据类型[] 数组名称[] ;
数据类型[][] 数组名称 ;
动态初始化:
格式1:
数据类型[][] 数组名称 = new 数据类型[m][n] ;
举例:
int[][] arr = new int[3][2] ;
=号左边:
int:当前数组存储的是int类型的元素
[][]:定义的是一个二维数组
arr :数组对象名称
=号右边:
new :在堆内存中创建该数组的对象(产生堆内存空间地址)
int:当前数组存储的是int类型的元素
[3]:当前定义的这个二维数组中有3个一维数组
[2]:每一个一维数组中有2个长度
注意:
在一些笔试题:定义变量 进行初始化
int x, y ; x 和y是两个int类型的变量
int x [],y[] ;x和y都是int类型的数组
int x[][],y[] ; x是一个二维数组,y是一个一维数组
二维数组的格式2:
指定了一维数组的个数,一维数组的长度需要动态给定
数据类型[][] 数组名称 = new 数据类型[m][] ;
举例:
int[][] arr = new int[3][] ;
二维数组的格式3:
就是静态初始化
数据类型[][] 数组名称 =
new 数据类型[][]{{元素1,元素2,元素3..},{元素1,元素2,元素3,...},{,}};
简写格式:
数据类型 [][] 数组名称 = {{元素1,元素2,元素3..},{元素1,元素2,元素3,...},{,}};
举例
int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}} ;
-->简写格式
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}} ;
//二维数组的遍历
class Array10{
public static void main(String[] args){
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
ChaoZhao(arr);
}
public static void ChaoZhao(int[][] arr1){
for(int x=0;x<arr1.length;x++){
for(int y=0;y<arr1[x].length;y++){
System.out.print(arr1[x][y]+" ");
}
}
}
}
第三天：
1.二维数组的应用：
二维数组的遍历
外层循环:其实是一维数组的个数(arr.length)
内层循环:其实每一个一维数组的长度(arr[x].length)
最终让你以:{{1,2,3},{4,5},{6}}按照这个格式
例题如下：
class Array2Test{
public static void main(String[] args){
//定义一个二维数组,静态初始化:
int[][] arr = {{1,2,3},{4,5},{6}};
//调用遍历的功能
printArray2(arr) ;
}
/*
两个明确
1)明确返回值类型:void
2)明确参数类型以及参数个数
1个参数 int类型二维数组
*/
public static void printArray2(int[][] arr){
//输出以下左大括号
System.out.print("{");
//遍历
for(int x = 0 ; x < arr.length; x++){//外层循环是一维数组的个数
//先输出左大括号
System.out.print("{");
//遍历一维数组的元素
for(int y = 0 ; y < arr[x].length ; y++){
//判断
//如果是二维数组的最后一个元素
if(x == arr.length-1){
//输出元素值以及后面的}
System.out.print(arr[x][y]+"}") ;
//如果当前元素取到的一维数组的最后一个元素
}else if(y == arr[x].length-1){
//输出元素内容以及}以及,
System.out.print(arr[x][y]+"}"+",") ;
}else{
System.out.print(arr[x][y]+",") ;
}
}
}
//输出整个右}
System.out.print("}");
}
}
例题2.
杨辉三角形：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
规律:
1)任意一行的第一列和最后一列都是1
2)从第三行开始中间每一个数据都等于上一行的前一列和上一行的本列之和
二维数组:int[][] arr = new int[m][n] ;
分析:
1)键盘录入一个数据: n
2)定义一个二维数组:n行n列 int[][] arr = new int[n][n] ;
3)遍历二维数组,先给任何一行的第一列以及任何一行的最后一列赋值为1
4)从第三行开始,遍历二维数组,给中间的数据填充:
从第三行开始中间每一个数据都等于上一行的前一列和上一行的本列之和
*/
//导包
import java.util.Scanner;
class Array2Test2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收
System.out.println("请您输入一个数据n:") ;
int n = sc.nextInt() ;
//定义一个二维数组
int[][] arr = new int[n][n] ;
//遍历二位数组,给任何一行的第一列和任何一行的最后一列赋值为1
for(int x = 0 ; x < arr.length ; x ++){
arr[x][0] = 1 ;
arr[x][x] = 1 ;
}
//填充中间的数据:
//从第三行开始中间每一个数据都等于上一行的前一列和上一行的本列之和
for(int x = 2 ; x < arr.length ; x ++){ //行数
//y:元素的内容
//y<=x-1 :考虑最后一列的问题 (中间的元素:考虑第一列和最后列)
for(int y = 1 ; y<= x -1 ; y++){//列
//第三行开始中间每一个数据都等于上一行的前一列和上一行的本列之和
arr[x][y] = arr[x-1][y-1] + arr[x-1][y] ;
}
}
//遍历二维数组
/*
for(int x = 0 ; x < arr.length ; x ++){
for(int y = 0 ; y < arr[x].length ; y++){
System.out.print(arr[x][y] +"\t") ;
}
System.out.println() ;
}
*/
//在杨辉三角中遍历二维数组---->类似与99乘法表
for(int x = 0 ; x < arr.length ; x ++){
for(int y = 0 ; y <=x ; y++){
System.out.print(arr[x][y] +"\t") ;
}
System.out.println() ;
}
}
}
2.面向对象：
1.对Student s = new Student();的解释说明
Student s = new Student();在内存中做了哪些事情?
加载Student.class文件进内存
在栈内存为s开辟空间
在堆内存为学生对象开辟空间
对学生对象的成员变量进行默认初始化
对学生对象的成员变量进行显示初始化
通过构造方法对学生对象的成员变量赋值，学生对象初始化完毕，把对象地址赋值给s变量。
学生类：
类和事物的关系：
学生事物
属性： 学生的编号，学生的姓名，学生的年龄，学生的性别
行为:吃饭,睡觉,打游戏,学Java
将上面的学生的描述使用代码体现出来,并且测试
学生事物-------------------> 定义学生类 class Student{}
属性---------------------->成员变量:id,name,age,gender(性别)
行为---------------------->成员方法(去掉static关键字):playGame(),study(),eat()
*/{
类 和 事物的关系:
事物:描述现实世界的真实存在泛指的东西!
学生----->学生事物
属性:姓名,年龄,学号,性别
行为:主要学习
类:是描述一组事物的属性和行为的集合
类: 是Java语言的最基本的单元
学生事物 ----------------
属性:描述学生的特征(姓名,年龄,学号,性别)
行为:描述学生能干什么(主要学习)
张三或者李四 ：具体事物
代码体现出来:类 学生类 class Student{}
成员变量：位置：在类中，方法外 （name,age,studyId,gender）
成员方法：study()
今天的成员方法去掉static
public 返回值类型 方法名（参数）{}
代码体系具体事物：创建该类对象
类名 对象名 = new 类名();
对象名.成员变量
对象名.name = "张三" ;
对象名.成员方法()
面向对象的最大特点：强调对象的创建，使用该对象调用自己的功能！
}
//定义学生类
class Student{
//成员变量:类中,方法外
int id ;//学生的编号
String name ; // 学生的姓名
int age ; //学生的年龄
String gender ; //学生的性别
//成员方法
//玩游戏
public void playGame(){
System.out.println("玩吃鸡...") ;
}
//学习的功能
public void study(){
System.out.println("学习Java语言...") ;
}
//吃饭
public void eat(String name){
System.out.println("在吃"+name) ;
}
}
//定义测试类
class StudentTest{
public static void main(String[] args){
//测试学生类
//创建该类对象:
//类名 对象名 = new 类名() ;
Student student = new Student() ;
//System.out.println(student) ; //[email protected] 地址值
System.out.println(student.id+"---"+student.name+"----"+student.age+"---"+student.gender) ;
//对象名访问成员变量
student.id = 1 ;
student.name = "高圆圆" ;
student.age = 20 ;
student.gender = "女" ;
System.out.println(student.id+"---"+student.name+"----"+
student.age+"---"+student.gender) ;
//对象名访问成员方法
student.playGame() ;
student.study() ;
student.eat("大盘鸡") ;
}
}
例题如下：
需求:
手机事物
属性:品牌(brand),价格(price),颜色(color),内存(memory)
行为:打电话,玩游戏,聊天
定义一个手机类(Phone),然后去测试手机类
手机类:class Phone
成员变量:brand,price,color,memory
成员变量:callPhone(String name),playGame(),chart()
*/
//手机类
class Phone{
//成员变量
String brand ; //品牌
double price ;//价格
String color ;//颜色
int memory ; //内存
//成员方法
public void callPhone(String name){
System.out.println("给"+name+"打电话") ;
}
public void playGame(){
System.out.println("手机可以王者农药") ;
}
public void chart(String name){
System.out.println("可以跟"+name+"聊天了") ;
}
}
//测试类
class PhoneTest{
public static void main(String[] args){
//创建一个手机类对象
Phone p = new Phone() ; //类名 对象名 = new 类名();
//没有给该p对象的成员变量赋值
System.out.println(p.brand+"---"+p.price+"---"+p.color+"---"+p.memory) ;
//给成员变量赋值
p.brand = "华为p40" ;
p.price = 4999.99;
p.color = "翡翠绿" ;
p.memory = 16 ;
System.out.println(p.brand+"---"+p.price+"---"+p.color+"---"+p.memory) ;
//访问成员方法
p.callPhone("高圆圆");
p.playGame() ;
p.chart("习总") ;
}
}
3.局部变量与成员变量的区别：
局部变量和成员变量的区别?(面试题)
1)在类中的位置不同
局部变量:在方法定义中或者是方法声明上的变量
成员变量:在类中,方法外定义的变量
2)在内存中的位置不同
局部变量:在栈内存中存储跟方法有关
成员变量:在堆内存中存储跟类的对象有关
3)生命周期不同
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失!
成员变量:随着对象的创建而存在,随着对象的创建完毕并且使用完毕,
等待垃圾回收器回收掉掉(GC)之后才消失!(不会立即被回收)
4)初始时机不同:
局部变量:在方法定义中或者方法声明上的变量,必须在使用之前进行数据初始化,否则"可能尚未初始化变量"
成员变量:跟对象有关系,在堆内存中,即使这个成员变量没有赋值,系统会根据变量的类型给这个变量进行默认初始化
4.形式参数是一个具体的类：
/*
解释说明:形式参数如果是一个基本数据类型,形参的改变对实际参数没有影响. 需要什么类型的数据,传递具体的值即可!
形式参数如果是一个类(具体类),那么形式参数的改变直接影响实际参数!
以后研究的引用类型
结论:
形式参数如果传递的是一个数组类型,需要传递的该数组的对象
举例:
//调用该方法的时候,形式参数要该数组对象 int[] arr = {1,2,3,4,5} ;
public static void printArray(int[] arr){}
形式参数如果传递的是一个具体类(jdk提供的,我们自定义的),需要传递该类的具体对象
举例:
class Student{
public void study(){....}
}
class StudentDemo{
public void method(Student s){ //让你创建学生对象Student 对象名 = new Student();
s.study() ;
}
}
*/
class Demo{
//求两个数据之和的功能
public int add(int a,int b){
return a+b;
}
}
//定义一个学生类
class Student{
//成员方法
public void study(){
System.out.println("Good Good Study ,Day Day Up!!!") ;
}
}
//在定义一个类StudentMethod
class StudentMethod{
//成员方法:有一个形式参数:Student
public void method(Student s){ //如果形式参数一个具体类,需要传递该类对象
//Student s = new Student() ; s.study();
s.study() ; //s变量访问study() ---->需要学生类具体对象才能访问这个study()
}
}
//测试类
class ArgsDemo{
public static void main(String[] args){
//需求:访问Demo类中的add方法
//创建该Demo类的具体对象
Demo d = new Demo() ;
int result = d.add(10,20) ;
System.out.println("结果是:"+result) ;
System.out.println("--------------") ;
//需求:要访问StudentMethod类中的method方法()
//创建StudentMethod类的对象,使用对象调用method()
StudentMethod sm = new StudentMethod() ;
// sm.method(Student s) ; sm.method(s) ;//找不到符号
//需要创建一个学生对象
Student student = new Student() ;
sm.method(student) ;//引用类型作为形参--->传递的是空间地址值!
/*
public void method(Student s){ //将学生对象传递进来student
s.study() z; //student.study() ;
}
*/
}
}
第四天：
1.匿名对象：
1.匿名对象:没有名字的对象
匿名对象的格式
new 类名() ; (前提条件:该类是一个具体类)
特点:
1.仅仅使用一次,使用完毕,从内存中会立即被释放掉! (节省内存空间,android移动端使用居多!)
2.匿名对象也可以作为参数进行传递
注意:
在使用匿名对象的时候,建议不使用多次!
StudentDemo sd = new StudentDemo() ;
//创建学生类对象
Student s = new Student() ; //对象名称叫s (有名称的对象)
sd.method(s) ;
System.out.println("-------------------------") ;
//使用匿名对象
sd.method(new Student()) ; //该学生的匿名对象作为参数传递
System.out.println("-------------------------") ;
2.封装：
引出封装的概念：
需求:
学生类:
姓名和年龄
使用StudentDemo类测试这个学生类
按照上面这个需求实现,发现一个问题,如果给学生的年龄赋值为一个非法数据,这个数据还被输出了!
2)
Java针对这种情况提供一个技术:封装:
将类中成员变量私有化(private),对 外提供公共的访问方法(权限足够大)
私有化的成员变量:只能在本类中,外界不能访问的!
3)
private关键字：
private关键字的特点:
1)private可以修饰一个类中的成员变量,也可以成员方法
2)被private修饰的成员变量或者是成员方法只能在本类中方法,外界不能访问的!(保证数据的安全性)
什么时候将变量定义为成员变量---->如果该变量能够描述某个事物属性的话,----变量就要定义成员变量!
4)
this关键字：
之前:标识符给变量/方法起名字,都要见名知意
当前学生类中的setName(String n),还有setAge(int a),变量n和a都不太合适
给学生赋值姓名 :name和年龄:age
按照上面这种方式改造---->局部变量和成员变量名称一样(局部变量隐藏了成员变量)
----为了区分成员变量和局部变量----java提供了一个关键字:this(代表了当前该类对象地址引用
setXXX(形参)方法,谁调用这个方法,那么this代表它(地址)
3.一个标准类的写法:
1.一个标准类的写法:
类
1)属性私有化
2)提供对外的公共的setXXX(形式参数)/getXXX()方法
3)构造方法:
永远给出无参构造方法;
有参构造
4.构造方法：
1.一个类的成员:
1)成员变量
2)成员方法
新的成员: 构造方法
什么是构造方法:
1)方法名和类名相同
2)没有具体的返回值类型
3)并且连void都没有
权限修饰符 + 方法名就是类名(){
}
构造方法主要作用:就是给该对象中的数据进行初始化!
2.构造方法中的注意事项:
1)在一个类中,我们不写无参构造方法,系统会默认的提供一个无参构造方法,
2)如果我们提供一个有参构造方法,系统不会在提供无参了,如果使用无参构造方法创建对象,就会报错!
(永远建议给出无参构造方法)!
5.成员变量：
1.
成员方法的分类:(非静态的成员方法)
两种情况:
要么有返回值类型
1)有返回值类型,并且有参数
2)有返回值类型,没有参数
要么没有具体返回值:void代替
1)没有返回值类型,带参
2)没有返回值类,不带参
*/
class StudentDemo{
//定义成员方法
//有返回来类型的情况
//有返回值,带参
public String method(String str){
return "hello"+str;
}
//有返回值,不带参的
public String function(){
return "hello JavaEE" ;
}
//没有返回值类型的情况
//没有返回值带参的 :void代替返回值类型
public void show(int num){
System.out.println(num);
function2() ;
}
//没有返回值,不带参的
private void function2(){
System.out.println("function2 StudentDemo") ;
}
}
//测试类
class MethodDemo{
public static void main(String[] args){
//访问这些成员方法:
//创建对象 :类名 对象名 = new 类名();
StudentDemo sd = new StudentDemo() ;
String result = sd.method("world") ;
System.out.println(result) ;
String s2 = sd.function() ;
System.out.println(s2) ;
sd.show(100) ;
//sd.function2() ;//function2() 在 StudentDemo 中是 private 访问控制
}
}
6.static关键字：
1.需求:
定义一个人类
属性:姓名,年龄,国籍
定义一个测试类测试这个"人类"
按照上面这个需求,测试之后,发现这四个人都"中国",从内存角度考虑,"中国"在堆内存中比较耗费内存空间
如何优化:想办法让着多个人共用一个国籍"中国"
Java提供了一个关键字:static "静态修饰符"
共享的,共用的
*/
//定义一个人类
class Person{
//定义三个成员变量
String name ; //null
int age ; //0
//String country ; //null
static String country ;
//提供两个参数的有参构造
public Person(String name,int age){
this.name = name ;
this.age = age;
}
//带三个参数的构造方法
public Person(String name,int age,String country){
this.name = name ;
this.age = age ;
this.country = country ;
}
//提供一个成员方法:show(),将成员变量输出
public void show(){
System.out.println("姓名是:"+name+",年龄是:"+age+",所在的国籍是:"+country);
}
}
//测试类
class PersonTest{
public static void main(String[] args){
//古代四大美女
//创建对象
Person p1 = new Person("貂蝉",25,"中国") ;
p1.show() ;
System.out.println("------------------") ;
//Person p2 = new Person("西施",22,"中国") ;
//改进:
Person p2 = new Person("西施",22) ;
p2.show() ;
System.out.println("------------------") ;
//Person p3 = new Person("杨玉环",20,"中国") ;
//改进:
Person p3 = new Person("杨玉环",20) ;
p3.show() ;
System.out.println("------------------") ;
//Person p4 = new Person("王昭君",28,"中国") ;
Person p4 = new Person("王昭君",28) ;
p4.show() ;
}
}
第五天：
1.static关键字的补充：
关于静态static的特点:
1)被static修饰的变量/方法 都随着类的加载而加载
class xxx{} ----> 通过javac 编译xxx.java文件 --->编译没有问题(Java语法校验)
---->产生xxx.class文件
java xxx类
2)被static修饰的 优先于对象存在
回想main :被静态修饰符: jvm调用它
public static void main(String[] args){
}
3)被static修饰的可以被多个对象共用
有共享,共用
举例:
班级的编号(同一个班级的都在共用编号)
水杯(不能被共用)
也在告诉我们,什么时候将变量定义静态变量
4)被静态修饰的成员变量或者成员方法 ,
可以被类名直接访问(推荐访问方式)
类名.成员方法;
类名.成员方法();
但是,也可以用该类对象来访问该成员(不推荐的!)
*/
class Demo{
//成员变量
int num = 100 ;
//静态成员变量
static int num2 = 50 ;
//成员方法
public void show(){
System.out.println("show Demo") ;
}
//静态的成员方法
public static void method(){
System.out.println("method Demo") ;
}
}
//测试类
class StaticDemo{
public static void main(String[] args){
Demo d = new Demo() ;
//访问非静态的成员变量,成员方法
System.out.println(d.num) ;
d.show();
System.out.println("-------------") ;
//对象名来访问静态成员
System.out.println(d.num2) ;
d.method();
System.out.println("-------------") ;
//推荐方式:静态成员 直接使用类名访问(static静态的随着类的加载而加载)
System.out.println(Demo.num2) ;
Demo.method();
}
}
2.static注意事项：
使用static关键字的注意事项:
1)在static中,是没有this关键字的! (this:代表当前类的对象的地址值,对象已经创建了而static修饰的
和类有关系);
2)关于成员方法的访问问题:
非静态的成员方法
既可以访问静态的成员变量,也可以访问非静态的成员变量
既可以访问静态的成员方法,也可以访问非静态的成员方法;
静态的成员方法
简单记:静态只能访问静态
*/
//自定义一个类
class Demo2{
//定义一个成员变量
int num = 100 ;
//静态成员变量
static int num2 = 200 ;
//成员方法
public void show(){
System.out.println(num2) ;
System.out.println(num) ;
}
//成员方法
public void method(){
show() ;
function() ;
}
//静态的成员方法
public static void function(){
System.out.println("这是静态的function方法...") ;
}
//静态的成员方法
public static void function2(){
System.out.println(num2) ;
//System.out.println(num) ; // 无法从静态上下文中引用非静态 变量 num
//show() ; 无法从静态上下文中引用非静态 方法 show()
function() ;
}
}
//测试
class StaticDemo2{
public static void main(String[] args){
//创建Demo2类的对象
Demo2 d = new Demo2() ;
d.show() ;
System.out.println("-------------------------") ;
d.method() ;
System.out.println("-------------------------") ;
d.function2() ;
System.out.println("-------------------------") ;
int result = sum(10,20) ; //静态只能访问静态!
System.out.println(result);
}
//求两个数据之和
public static int sum(int a,int b){
return a + b ;
}
}
3.面向对象（求长方形的面积和周长的的练习）：
/*
需求:键盘录入长方形的长和宽,求面积和周长
分析:
长方形: ------ > 长方形类(ChangFangXing)
有两个属性:长和宽 length,width 成员变量
行为:面积,周长 --->功能:成员方法 getZhouChang() getArea()
*/
//导包
import java.util.Scanner ;
//定义长方形类
class ChangFangXing{
//属性私有化
private int length ; //长
private int width ;//宽
public ChangFangXing(){
}
//提供setXXX(形参)赋值公共访问方法
public void setLength(int length){
this.length = length ;
}
public void setWidth(int width){
this.width = width ;
}
//定义求周长和面积的成员方法
public int getZhouChang(){
return (length+width)*2 ;
}
public int getArea(){
return length * width ;
}
}
//测试类
class Test2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收
System.out.println("请输入长方形的长:") ;
int length = sc.nextInt() ;
System.out.println("请输入长方形的宽:") ;
int width = sc.nextInt() ;
//创建长方形类的对象
//封装思想:
ChangFangXing
cfx = new ChangFangXing() ;
cfx.setLength(length) ;
cfx.setWidth(width) ;
System.out.println("该长方形的周长是:"+cfx.getZhouChang()) ;
System.out.println("该长方形的面积是:"+cfx.getArea()) ;
}
}
4.面向对象例题（员工类）
/*
定义一个员工类,
自己分析属性以及行为,去测试员工类
分析:
员工事物:
属性:
员工编号,姓名,年龄,性别..
行为:
抽烟,没日没夜敲代码工作
员工类
成员变量:
empId,empName,empAge,empGender
成员方法:
提供setXXX()/getXXX()公共访问方法
无参构造以及有参构造
成员方法:
smoke() ,coding()
*/
//员工类
class Employee{
private String empId ;
private String empName; //private String Name; 不要这样出现!(SSM框架:Name可能找不到) private String name
private int empAge;
private String empGender ;
//提供无参构造以及有参构造
public Employee(){}
public Employee(String empId,String empName,int empAge,String empGender){
this.empId = empId ;
this.empName = empName ;
this.empAge = empAge;
this.empGender = empGender ;
}
//提供setXXX()/getXXX()
public void setEmpId(String empId ){
this.empId = empId ;
}
public void setEmpName(String empName ){
this.empName = empName ;
}
public void setEmpAge(int empAge){
this.empAge = empAge;
}
public void setEmpGender(String empGender ){
this.empGender = empGender ;
}
public String getEmpId(){
return empId;
}
public String getEmpName(){
return empName ;
}
public int getEmpAge(){
return empAge;
}
public String getEmpGender(){
return empGender;
}
public void smoke(String name){
System.out.println("该员工抽"+name) ;
}
public void coding(){
System.out.println("日日夜夜敲代码...") ;
}
}
//测试类
class Test3{
public static void main(String[] args){
//方式1:无参构造方法创建对象 +setXXX(形参)赋值
Employee emp = new Employee() ;
emp.setEmpId("9527");
emp.setEmpName("高圆圆") ;
emp.setEmpAge(39) ;
emp.setEmpGender("女");
System.out.println(emp.getEmpId()+"---"+emp.getEmpName()+"---"+emp.getEmpAge()+"---"
+emp.getEmpGender()) ;
emp.smoke("苏烟");
emp.coding();
System.out.println("----------------------------") ;
//方式2:有参构造方式
emp = new Employee("9528","赵又廷",44,"男") ;
System.out.println(emp.getEmpId()+"---"+emp.getEmpName()+"---"+emp.getEmpAge()+"---"
+emp.getEmpGender()) ;
emp.smoke("华子");
emp.coding();
}
}
5.文档说明书的制作：
1./*
在ArrayDemo类中测试一个针对数组操作的工具类
1)工具类ArrayTool---> 无参构造私有化了
2)定义相关的功能(静态的功能)
3)提供相关文档注释 /星星 文档注释 星
在类上以及方法上都需要加上文档注释
4)针对ArrayTool工具类---->产生描述该类的文档
在dos中:javadoc -d 目录名字 -author -version ArrayTool.java
*/
//测试类
class ArrayDemo{
public static void main(String[] args){
//定义数组:静态初始化
int[] arr = {57,12,24,69,80} ;
//测试ArrayTool类的功能
ArrayTool.printArray(arr) ;
int max = ArrayTool.getMax(arr) ;
System.out.println(max) ;
int index = ArrayTool.getIndex(arr,240) ;
System.out.println(index) ;
}
}
2./**
该类是自定义的针对数组操作的工具类
@author apple
@version V1.0
*/
public class ArrayTool{
//无参构造私有化,目的:外界不能直接创建对象!
private ArrayTool(){
}
/**
该方法是针对数组遍历的功能,将数组以[元素1, 元素2, ..]该格式输出
@param 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.println(arr[x]+"]") ;
}else{
System.out.print(arr[x] +", ") ;
}
}
}
/**
该方法是获取数组中的最大值
@param arr 在指定的数组中获取最大值
@return 返回最大值
*/
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 ;
}
/**
该方法是在指定的数组中查询指定元素角标值
@param arr 在指定的数组中查询
@param key 要查询的指定数组中元素
@return 如果查找到了,返回该角标值,如果没有查找到,返回-1
*/
public static int getIndex(int[] arr,int key){
//假设实现
int index = -1 ;
for(int x = 0 ; x < arr.length ; x ++){
if(arr[x] == key){
index = x ;
break ;
}
}
return index ;
}
}
6.创建对象做了那些事:
Student s = new Student();
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZMmqBwI5-1595593388100)(C:\Users\张强\AppData\Roaming\Typora\typora-user-images\image-20200724201448098.png)]
1.栈内存：存储局部变量（在方法定义中或者方法声明上）。
栈：先进后出；队列：先进先出
2.堆内存：new出来，系统默认初始化，显示初始化；
堆：
1.申请堆内存空间；
2.系统默认初始化：
3.显示初始化
4.当内存分配完毕时，使用完这个对象，不会立即被GC回收掉，等待GC空闲时。
int（默认为0），float默认为double 0.0；char 默认为‘\u000’；
boolean默认为false，引用类型默认为null。
3.方法区，面向对象（class区，static区，字符串常量区）
4.本地方法区：（与系统有关）
5.寄存器（与cpu有关）
}
}
2./**
该类是自定义的针对数组操作的工具类
@author apple
@version V1.0
*/
public class ArrayTool{
//无参构造私有化,目的:外界不能直接创建对象!
private ArrayTool(){
}
/**
该方法是针对数组遍历的功能,将数组以[元素1, 元素2, ..]该格式输出
@param 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.println(arr[x]+"]") ;
}else{
System.out.print(arr[x] +", ") ;
}
}
}
/**
该方法是获取数组中的最大值
@param arr 在指定的数组中获取最大值
@return 返回最大值
*/
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 ;
}
/**
该方法是在指定的数组中查询指定元素角标值
@param arr 在指定的数组中查询
@param key 要查询的指定数组中元素
@return 如果查找到了,返回该角标值,如果没有查找到,返回-1
*/
public static int getIndex(int[] arr,int key){
//假设实现
int index = -1 ;
for(int x = 0 ; x < arr.length ; x ++){
if(arr[x] == key){
index = x ;
break ;
}
}
return index ;
}
}
#### **6.创建对象做了那些事:**
Student s = new Student();
[外链图片转存中...(img-ZMmqBwI5-1595593388100)]
1.栈内存：存储局部变量（在方法定义中或者方法声明上）。
栈：先进后出；队列：先进先出
2.堆内存：new出来，系统默认初始化，显示初始化；
堆：
1.申请堆内存空间；
2.系统默认初始化：
3.显示初始化
4.当内存分配完毕时，使用完这个对象，不会立即被GC回收掉，等待GC空闲时。
int（默认为0），float默认为double 0.0；char 默认为‘\u000’；
boolean默认为false，引用类型默认为null。
3.方法区，面向对象（class区，static区，字符串常量区）
4.本地方法区：（与系统有关）
5.寄存器（与cpu有关）
上一篇： 快科技2019年度评奖：手机处理器篇
下一篇： AC自动机学习总结