选择,循环结构；分支语句；数组；面向对象；this关键字.
周总结
- 一.学习选择,分支语句
-
- 1.选择结构语句
-
- swit语句
- 2.分支语句
-
- if语句基本格式
- if语句格式二
- if语句格式三
- 2.循环语句
-
- for循环语句
- while循环语句
- do while循环语句
- 二.学习循环语句的嵌套
-
- for语句嵌套
- 三.学习数组的使用
-
- 什么是数组
- 遍历数组
- 求数组中最大/最小值
- 将数组进行逆序
- 查找元素
- 四.学习面向对象
-
- 什么是类
- 数组高级排序之冒泡
- 匿名对象
- 成员变量私有化
- 五.接触this关键字
-
- 什么是this关键字
一.学习选择,分支语句
1.选择结构语句
swit语句
下面展示switch格式 内联代码片。
switch(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break ;
....
....
default:
语句n+1;
break ;
}
重点:
面试题:
switch后面的表达式可以是什么样的数据类型?
最基本的:byte,short,int,char
JDK5以后可以是枚举类型
JDK7以后可以是String类型 (引用类型)
例题:
需求:
键盘录入一个数据(int),判断当前是星期几
1,星期一
2,星期二
3,星期三
4,星期四
5,星期五
6,星期六
7,星期日
import java.util.Scanner ;
public class SwitchDemo {
public static void main(String[] args){
//创建键盘录入数据
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个int数据:");
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 ;
}
}
}
2.分支语句
下面展示if语句的几种格式
if语句基本格式
if(表达式){
语句....
}
针对某一种情况进行判断
if语句格式二
针对两种情况进行判断
if(表达式){
语句1;
}else{
语句2;
}
注意:
If语句格式2和三元运算符的区别?
if(表达式){
语句1;
}else{
语句2;
}
(表达式)? 执行true的结果:执行false的结果;
if语句:既可以操作两个数据的数值,也可以操作语句!(使用范围场景更大)
三元运算符:是针具体数据进行运算
如果能够使用三元运算符实现的,一定能够使用if格式2;
能够使用if格式2实现的不一定能够使用三元运算符
if语句格式三
针对多种情况进行判断
if(表达式1){
语句1;
}else if(表达式2){
语句2;
}else if(,,,,){
...
...
...
}else{
语句n+1;
}
2.循环语句
for循环语句
for循环的格式
for(初始化语句;条件判断语句;步长语句(控制体语句)){
循环体语句;
}
流程:
1)先执行初始化语句对变量进行赋值(只执行一次)
2)判断条件语句是否成立,如果成立,执行 循环体语句
3)执行步长语句(++,--)
4)继续判断条件是否成立,如果还成立, 执行 循环体语句
5)继续执行步长语句(++,--)
...
...
n)当前条件不成立,for循环结束
例题:
需求:
请求控制台打印10次"helloworld"
public class Demo {
public static void main(String[] args){
for(int x = 1 ; x <= 10 ; x ++){
//x =1 ， x <= 10 第一次
//x ++，x=2 ， 2<=10 第二次
//x ++ , x=3 ， 3<=10 第三次
//x ++,x =4 ,4<=10 第四次
//...
//x++, x = 10 ，10<=10 第十次
//x ++ ,x =11 , 11<=10 不成立了，for循环结束了
System.out.println("helloworld");
}
}
}
while循环语句
while循环的基本格式:
while(条件表达式){
循环体语句;
控制体/步长语句;
}
扩展格式:
* 初始化语句;
* while(条件判断语句){
* 循环体语句;
* 控制体/步长语句;
* }
流程:
* 初始化语句执行一次
* 判断条件是否成立,成立,则执行循环体,再依次执行步长语句;
* ...
* 如果不成立,while循环语句结束!
例题:
输出所有的水仙花数
int j = 100 ;
while(j<1000){
//定义三个变量:ge shi bai
int ge = j % 10 ;
int shi = j /10 % 10 ;
int bai = j /10 /10 % 10 ;
if(j == (ge*ge*ge+shi*shi*shi+bai*bai*bai)){
//输出
System.out.println(j) ;
}
j ++ ;
}
输出五次"我爱java"
public class WhileDemo {
public static void main(String[] args){
int x = 1 ;
while(x<=5) {
System.out.println("我爱java") ;
x ++ ;//步长语句
}
在循环的过程中,没有控制变量,导致程序中永远"恒成立"
for(;;){
语句;
}
while(true){
语句...
}
例题:
public class WhileTest2 {
public static void main(String[] args) {
for(;;){
System.out.println("学习java,我很开心") ;
}
do while循环语句
格式:
初始化语句;
do{
循环体语句;
步长语句/控制体语句;
}while(条件表达式) ;
流程:
初始化语句执行一次,对变量进行赋值
执行循环体语句,
执行步长语句(++或者--)
判断while后的条件是否成立,成立,继续执行循环体语句...
不成立,语句结束!
public class DoWhileDemo {
public static void main(String[] args){
//控制台输出5次"helloworld"
// int i = 1 ;
int i = 6 ;
do{
System.out.println("helloworld") ;
i++;
}while(i<=5) ;
}
}
注意:
do-while循环和for循环以及while循环的最大的区别就是:循环体至少执行一次!
二.学习循环语句的嵌套
for语句嵌套
for循环嵌套
for(初始化语句;条件表达式;步长语句){
//内层循环是外层循环的循环体语句
for(初始化语句;条件表达式;步长语句){
循环体语句;
}
}
例题:
需求:
控制台输出*形(4行5列的*)
public class ForForDemo {
public static void main(String[] args){
for(int x = 0; x < 4 ; x ++ ){//x =0 ,1,2,3 //控制行数
for(int y = 0 ; y < 5; y++){//y =0,1,2,3,4 //控制列数
System.out.print("*") ;
}
System.out.println() ;
}
}
}
for (循环）“百钱买百鸡”是我国古代的著名数学题。题目这样描述：3 文
钱可以买1只公鸡，2 文钱可以买一只母鸡，1 文钱可以买3 只小鸡。用100 文
钱买100 只鸡，那么各有公鸡、母鸡、小鸡多少只？
public class for_test {
public static void main(String[] args){
//定义三个变量:分别代表:公鸡,母鸡,小鸡
int x ,y,z ;
//公鸡的范围
for( x = 0 ; x <=33 ; x ++){
//母鸡的范围
for(y = 0 ; y <= 50 ; y ++){
//小鸡的数量:
z = 100 - x - y ;
//满足的条件
if(z % 3 == 0){
//并且满足条件:总数量加起来100只
if((3*x + 2*y+z/3)==100){
//公鸡,母鸡,小鸡
System.out.println("公鸡有"+x+"只"+"\t"+"母鸡有"+y+"只"+"\t"+"小鸡有"+z+"只") ;
}
}
}
}
}
}
三.学习数组的使用
什么是数组
容器:就是能够存储很多数据---先讲"数组"
数组是一个容器,能够存储同一种类型元素的容器!
格式:
数据类型[] 变量名称 ;
数据类型 变量名称[] ;
举例:
int[] arr ; 定义了一个int数组的arr变量 (推荐这个格式)
int arr[] ; 定义一个int类型的arr数组
数组的如何初始化
两种初始化:
第一种初始化: 动态初始化
第二种初始化:静态初始化
动态初始化: 给定数组的长度,元素由系统默认初始化!
格式:
数据类型[] 数组名称 = new 数据类型[长度] ;
数据类型 数组名称[] = new 数据类型[长度] ;
静态标准格式:
数据类型[] 数组名称 = new 数据类型[]{
元素1,元素2,元素3.....} ;
数据类型 数组名称[] = new 数据类型[]{
元素1,元素2,元素3....} ;
简写格式
数据类型[] 数组名称 = {
元素1,元素2,元素3.....} ; (推荐)
数据类型 数组名称[] = {
元素1,元素2,元素3.....} ;
注意事项:
//int[] arr = new int[5]{11,22,33,44,55} ;
//错误的:数组初始化只能有一种:不能既动态初始化,又静态初始化
遍历数组
查找方法:
基本元素查找法:(从头查到尾)
查询一个数组中的某个元素第一次在数组中出现的索引值(不考虑重复元素)
例题:
public class ArrayTest4 {
public static int getIndex(int[] arr,int key){
//如果传递了数组中没有的元素 200
//遍历数组
for(int x = 0 ; x < arr.length ; x ++){
//判断如果key就是要找的元素
if(key == arr[x]){
//获取这个角标
return x ;
}
}
//java中:查询元素,如果找不到,返回结果负数 ()
return -1 ;
}
}
求数组中最大/最小值
思路:
假设法:
定义一个最大值max
当前数组中第一个元素arr[0]是最大值
从角标1开始,遍历后面的元素
判断:如果后面的元素都比max大的话,当前arr[0]不是最大值
只需要改变max的值
例题:
public class ArrayTest2 {
public static int getMin(int[] arr){
//定义参照物
int min = arr[0] ;
//从角标1开始遍历元素
for(int x = 1 ; x < arr.length ; x ++){
//判断后面的元素依次和max进行比较
if(arr[x] < min){
min = arr[x] ;
}
}
return min ;
}
}
将数组进行逆序
思路:
分析:
1)定义功能----将原数组,先进行遍历 (逆序之前)
[12, 87 ,69, 24, 65]
2)逆序(方法)
将arr[0]元素和arr[arr.length-1]的进行互换
将arr[1]元素和arr[arr.length-1-1]的元素进行互换
...
保证当前元素的范围:角标0开始 数组长度/2
3)再次调用遍历数组的功能
例题:
public static void reverse(int[] arr){
//数组
// 保证当前元素的范围:角标0开始 数组长度/2
for(int x = 0 ; x < arr.length/2 ;x ++){
//定义中间变量
int temp = arr[x] ;
arr[x] = arr[arr.length-1-x] ;
arr[arr.length-1-x] = temp ;
}
}
//遍历
var foo = 'bar'; //遍历的功能
public static void printArray(int[] arr){
System.out.print("[") ;
//遍历元素
for(int x = 0 ; x < arr.length ; x ++){
//x表示角标值0,
//判断:x是否为最大索引值:
//如果是最大索引值,取到最后一个元素了arr[arr.lenght-1]
if(x == arr.length-1){
System.out.println(arr[x]+"]");
}else{
//中间的元素
System.out.print(arr[x]+", ") ;
}
}
}
}
public class change_ {
public static void main (String [] args){
int [] aa = {1,2,3,4,5,6,7,8,9};
shunxu(aa);
nixu(aa);
shunxu(aa);
}
//输出
public static void shunxu (int []aa){
System.out.print("[");
for(int x = 0 ; x < aa.length ; x ++){
if (aa.length-1 == x){
System.out.println(aa[x]+"]");
}else{
System.out.print(aa[x] + ", ");
}
}
}
//顺序颠倒
public static void nixu ( int []aa){
for (int y = 0 ; y < aa.length/2 ; y ++ ){
int temp = aa[y];
aa[y] = aa[aa.length-1 - y];
aa[aa.length-1 - y] = temp;
}
}
}
查找元素
思路:
基本元素查找法:(从头查到尾)
查询一个数组中的某个元素第一次在数组中出现的索引值(不考虑重复元素)
public class ArrayTest4 {
public static void main(String[] args){
//定义一个数组,静态初始化
int[] arr = {
13,67,89,100,230,97} ;
//调用:获取角标值的方法
//int index = getIndex(arr, 67);
// System.out.println("index:"+index) ;
int index = getIndex(arr, 200);
System.out.println("index:"+index) ;
System.out.println("-----------------------");
int index2 = getIndex2(arr,97) ;
int index3 = getIndex2(arr,500) ;
System.out.println("index2:"+index2);
System.out.println("index3:"+index3);
}
//方式2:假设思想
public static int getIndex2(int[] arr,int key){
//先定义一个角标值:index
int index = -1 ; //找不到
//遍历数组
for(int x = 0 ; x < arr.length ;x ++){
//如果当前key就是arr[x]
if(key == arr[x]){
//改变index的值
index = x ;
break; //结束循环
}
}
return index ;
}
/**
* 定义获取数组中的元素角标值的方法
* 两个明确:
* 1)明确返回值类型: int
* 2)明确参数类型以及参数个数
* int类型数组以及查找的元素,2个
*/
public static int getIndex(int[] arr,int key){
//如果传递了数组中没有的元素 200
//遍历数组
for(int x = 0 ; x < arr.length ; x ++){
//判断如果key就是要找的元素
if(key == arr[x]){
//获取这个角标
return x ;
}
}
//java中:查询元素,如果找不到,返回结果负数 ()
return -1 ;
}
}
例题:
package com.homework_;
//9.int[] arr = {10,55,30,24,17} ;
//查询30这个元素第一次在数组中出现的索引,查询元素使用功能完成!
public class chaxun_ {
//创建数组
public static void main (String [] args){
int [] aa = {
10,55,30,24,17} ;
int i = num( aa , 24);
System.out.println("num:" + i);
}
public static int num( int []aa,int key){
int i = -1 ;//未找到
for ( int y = 0 ; y < aa.length ; y ++ ){
if ( key ==aa[y]){
i = y ;
break;
}
}
return i ;
}
}
四.学习面向对象
什么是类
类----- 描述 "现实世界的事物"
--- 事物 (学生/老师/军人/工人....)
属性:姓名,年龄,身高,性别....
行为:学生--学习,老师---讲课
军人--保家卫国...
以Java语言的程序体现出来!
类
成员变量:
成员方法
基本数据类型作为形式参数传递有什么特点:
基本类型作为形式参数传递,形式参数的改变不会影响实际参数,
实际参数是什么,它的值还是那个原来的数据!
引用数据类型作为形式参数传递有什么特点: (后期研究的肯定是引用类型)
引用类型(数组,类,接口) 作为形式参数传递,形式参数的改变会直接影响实际参数!
示例:
public class ArgsDemo_ {
public static void main(String[] args){
//定义两个变量
int a = 10 ;
int b = 20 ;
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
System.out.println("-----------------") ;
//调用change方法
change(a,b) ;
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
System.out.println("-----------------") ;
//创建一个数组
int[] arr = {
1,2,3,4,5} ;
//int[] arr = new int[]{1,2,3,4,5} ;
System.out.println(arr);
System.out.println(arr[1]) ; //2
change(arr) ;
System.out.println(arr[1]) ;
}
//重载的change方法
public static void change(int[] arr){
//地址值
//遍历数组
for(int x =0 ; x < arr.length ; x ++){
if(arr[x] % 2 == 0){
arr[x] *= 2;
}
}
}
//change方法传递的是两个基本类型
public static void change(int a,int b){
//形式参数
System.out.println("a:"+a);
System.out.println("b:"+b) ;
System.out.println("===================================") ;
a = b ;
b = a+ b ;
System.out.println("a:"+a);
System.out.println("b:"+b) ;
}
}
数组高级排序之冒泡
思路:
两两比较,第一次比较完毕,最大值出现在最大索引处
依次这样比较
规律:
两两比较,第一次比较完毕,最大值出现了
每次比较完毕,下一次减少比较
第一次:有0个不比
第二次,有1个不比
第三次,有2个不比
第三次,有3个不比
最终比较的次数:数组长度-1次
示例:
public class bubble_ {
public static void main(String[] args){
//已知一个数组
int[] arr = {
24,69,87,57,13} ; //无序的数组
System.out.println("排序在之前:");
printArray(arr);
/*//第一次比较
//arr.length-1:为了防止角标越界
//arr.length-0:第一次比较:0个不比 (为了减伤比较的次数)
for(int x = 0 ; x < arr.length-1-0; x ++){
//判断:如果前面的元素比后面元素大,将大的元素往后方法
//交互元素----采用中间变量的方式
if(arr[x] > arr[x+1]){
int temp = arr[x] ;
arr[x] = arr[x+1] ;
arr[x+1] = temp ;
}
}
System.out.println("-----------------------------");
System.out.println("第一次比较完毕:");
printArray(arr);
System.out.println("-----------------------------");
//第二次比较
//arr.length-1:为了防止角标越界
//arr.length-1-1:第二次比较:有1不比
for(int x = 0 ; x < arr.length-1-1;x++){
//判断:如果前面的元素比后面元素大,将大的元素往后方法
//交互元素----采用中间变量的方式
if(arr[x] > arr[x+1]){
int temp = arr[x] ;
arr[x] = arr[x+1] ;
arr[x+1] =temp ;
}
}
System.out.println("第二次比较完毕:");
printArray(arr);
System.out.println("--------------");
//第三次比较
//arr.length-1:为了防止角标越界
//arr.length-1-2:第二次比较:有1不比
for(int x = 0 ; x < arr.length-1-2;x++){
//判断:如果前面的元素比后面元素大,将大的元素往后方法
//交互元素----采用中间变量的方式
if(arr[x] > arr[x+1]){
int temp = arr[x] ;
arr[x] = arr[x+1] ;
arr[x+1] =temp ;
}
}
System.out.println("第三次比较完毕:");
printArray(arr);
System.out.println("-------------------------") ;
//第四次比较
//arr.length-1:为了防止角标越界
//arr.length-1-3:第二次比较:有1不比
for(int x = 0 ; x < arr.length-1-3;x++){
//判断:如果前面的元素比后面元素大,将大的元素往后方法
//交互元素----采用中间变量的方式
if(arr[x] > arr[x+1]){
int temp = arr[x] ;
arr[x] = arr[x+1] ;
arr[x+1] =temp ;
}
}
System.out.println("第四次比较完毕:");
printArray(arr);*/
//上面代码重复比较高的,使用循环思想改进:
//总共循环了四次
for(int x = 0 ; x < 4 ; x ++){
//0,1,2,3 :循环的次数
for(int y = 0 ; y < arr.length-1-x;y++){
//判断:如果前面的元素比后面元素大,将大的元素往后方法
//交互元素----采用中间变量的方式
if(arr[y] > arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] =temp ;
}
}
}
//输出
System.out.println("排序完毕后:");
//将数组遍历
printArray(arr);
System.out.println("-----------------------------");
//上面的代码:4: 循环的次数-----写死了
//冒泡排序比较的次数:就是数组长度-1次
for(int x = 0 ; x < arr.length-1 ; x ++){
//0,1,2,3 :循环的次数
for(int y = 0 ; y < arr.length-1-x;y++){
//判断:如果前面的元素比后面元素大,将大的元素往后方法
//交互元素----采用中间变量的方式
if(arr[y] > arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] =temp ;
}
}
}
//输出
System.out.println("排序完毕后:");
//将数组遍历
printArray(arr);
System.out.println("--------------------------------");
//调用方法来完成:排序
bubbleSort(arr);
//遍历
printArray(arr);
}
/**
* 最终版代码:
* 定义一个方法:专门来对数组进行冒泡排序的
* 两个明确
* 1)明确返回值类型: void (没有具体返回值类型)
* 2)明确参数类型以及参数个数
* int[] ,1个参数
*/
public static void bubbleSort(int[] arr){
for(int x = 0 ; x < arr.length-1 ; x ++){
//0,1,2,3 :循环的次数
for(int y = 0 ; y < arr.length-1-x;y++){
//判断:如果前面的元素比后面元素大,将大的元素往后方法
//交互元素----采用中间变量的方式
if(arr[y] > arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = 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.println(arr[x]+"]") ;
}else{
System.out.print(arr[x]+", ") ;
}
}
}
}
例题:
package HomeWork_;
//3.自定义一个数组,进行冒泡排序,并按照[元素1, 元素2, 元素3, 元素4]输出
public class bubble_ {
//定义数组
public static void main (String []args){
int [] aa = {
9,6,7,4,2};
sort(aa);
num(aa);
}
//调整顺序
public static void sort (int [] aa){
//调整次数
for (int x = 0 ; x < aa.length-1 ; x ++ ){
//每两位调整
for (int y = 0 ; y < aa.length -1-x ; y ++){
if (aa[y] > aa[y+1]){
int temp = aa[y];
aa[y] = aa[y+1];
aa[y+1] = temp;
}
}
}
}
//遍历
public static void num( int [] aa){
System.out.print("[");
for (int a = 0 ; a < aa.length ; a ++){
if ( a == aa.length-1){
System.out.println(aa[a] + "]");
}else {
System.out.print(aa[a] + ", ");
}
}
}
}
例题:
package HomeWork_;
//4.学生有姓名,年龄,性别属性,行为有学习,
//睡觉以及玩游戏的行为,请使用面向对象方式书写学生类并且进
//创建类
class peo{
//定义成员变量
int age ;
int high;
String name;
String sex;
//定义方法
public void study(String x ){
System.out.println("学习"+x);}
public void sleep(String y ){
System.out.println("睡觉"+y);}
public String game (){
return "游戏";}
}
//测试类
public class Student_ {
public static void main (String [] args){
//创建类对象
peo a = new peo();
//成员变量赋值
a.age = 19;
a.high = 188;
a.name = "哪吒";
a.sex = "男";
//测试类方法
a.sleep("JAVA");
a.study("天亮") ;
String game = a.game();
System.out.println("游戏");
}
}
匿名对象
概念:
匿名对象:顾名知意: 没有名字的对象
类名 对象名 = new 类型() ; 有名字的对象
匿名对象的格式:
new 类名() ;
new 类名().成员方法名() ; 访问当前类中的成员方法
1)匿名对象:使用完毕,会立即垃圾回收器回收,节省内存空间!
应用场景:都是在移动端使用居多---Android :基于Java
(大部分都是使用匿名对象,节省内存)
2)开发中,匿名对象使用一次即可,不要使用多次!
(使用完毕,就立即被回收)
3)匿名对象可以作为参数传递
示例:
class Student{
public void study(){
System.out.println("好好学习,天天向上!") ;
}
}
//定义一个类StudentDemo
class StudentDemo{
public void method(Student student){
//形式参数一个引用类型:
//Student ----实际参数传递:Student s= new Student() l
student.study();
}
}
/**
*测试类
*/
public class NoNameDemo {
public static void main(String[] args){
//Java中创建类的对象的标准格式
//类名 对象名 = new 类名() ;
Student s = new Student() ;
s.study();
System.out.println("----------------------");
// new 类名() ; 对象
new Student().study();
System.out.println("----------------------");
//需求:访问StudentDemo类中method方法
//创建StudentDemo类对象
StudentDemo sd = new StudentDemo() ;
//调用method方法
//创建具体学生对象
Student student = new Student() ;
sd.method(student);
System.out.println("----------------------");
//匿名对象作为参数传递
//需求:访问StudentDemo类中method方法
//创建StudentDemo类对象
StudentDemo sd2 = new StudentDemo() ;
sd2.method(new Student());
System.out.println("==========================");
//需求:访问StudentDemo类中method方法
//使用匿名对象优化
//链式编程 :开发中使用不多(自己玩可以使用)
new StudentDemo().method(new Student());
}
}
成员变量私有化
概念:
Java提供一个关键字:private 封装
将一个类中的成员变量(属性)私有化,对外提供公共的访问方法,
来保证类的安全性!
目的:为了外界不能够直接访问
private(私有)关键字:
被private修饰的成员变量,成员方法只能在本类中访问,外界类不能访问
示例:
//定义一个类 Code
class Code{
//private可以修饰成员变量,修饰成员方法
//定义两个成员变量
public int num = 10 ;
private int num2 = 20 ;
//定义公共的成员方法
public void method(){
System.out.println("method code...");
System.out.println(num);
System.out.println(num2);
}
//私有的成员方法
private void function(){
System.out.println("function code...");
}
//定义公共方法
public void show(){
function();
}
}
//测试类
public class PrivateDemo {
public static void main(String[] args){
//需求:访问Code类中num和num2变量
//创建Code类对象
Code c = new Code();
System.out.println(c.num);
System.out.println("-----------------------------");
// System.out.println(c.num2); //不能外界类访问
//外界类可以通过公共的方法间接访问私有的成员变量
c.method();
// c.function() ;//function()方法是私有的,只能在本类中访问
System.out.println("------------------------------");
//可以间接的访问私有的方法----通过公共的访问
c.show();
}
}
示例:
class Student{
//成员变量
String name ;//姓名
//private int age ; //年龄 加入private修饰
int age ;//年龄
String sex ; //性别
//定义一个方法:专门判断年龄的值
public void setAge(int num){
if(num<0|| num <150){
System.out.println("当前年龄是一个非法数据");
}else{
//正常数据
//赋值
age = num ;
}
}
//成员方法
public void study(){
System.out.println("学习JavaSE...");
}
//展示信息
public void show(){
System.out.println("学生的姓名是:"+name+",年龄是:"+age+",性别是:"+sex);
}
}
//测试类
public class StudentTest {
public static void main(String[] args){
//创建一个学生对象
Student s = new Student() ;
//给学生对象s进行成员变量赋值
s.name = "高圆圆";
s.age = 41 ;
s.sex = "女" ;
s.show();
s.study();
System.out.println("------------------------------");
/* //创建第二个学生对象s2
Student s2 = new Student();
//给成员变量赋值
s2.name = "赵又廷" ;
s2.age = -39 ;
s2.sex ="男" ;
s2.show();
s2.study();*/
//改进代码之后:
Student s2 = new Student();
s2.name ="赵又廷" ;
// s2.setAge(-41); //年龄赋值: 通过setAge()方法赋值
s2.age = -41 ;
s2.sex ="男" ;
s2.show();
}
}
五.接触this关键字
什么是this关键字
学生类
n,a,s----分别代表:姓名,年龄和性别
定义变量:标识符的规则:---见名知意
改造---将n--name
a -- age
s --sex
发现:没有办法区分:哪一个name,age,sex是局部变量还是成员变量
Java提供了一个关键字-----this (解决----局部变量将成员变量隐藏了)
this:代表当前这个类的对象的地址值引用
public class Student {
//属性私有化
private String name ;//姓名
private int age ;//年龄
private String sex ;//性别
//提供对外的公共的访问方法
// public void setName(String n){
public void setName(String name){
this.name = name ;
}
public String getName(){
// return this.name ;
return name ; //return 里面隐藏了this关键字(一般不写)
}
// public void setAge(int a){
public void setAge(int age){
this.age = age ;
}
public int getAge(){
return age ;
}
// public void setSex(String s){
public void setSex(String sex){
this.sex = sex ;
}
public String getSex(){
return sex;
}
//成员方法
public void study(){
System.out.println("学习JavaEE...");
}
//爱好
public void hobit(){
System.out.println("爱生活,爱Java...");
}
}