标签：总结 语句 arr int JAVA2011 第二周 数组 public 循环
第二周知识点总结
1.switch语句
1.switch
选择结构语句之switch它的标准结构:
switch(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break ;
…
…
default:
语句n+1;
break ;
}
执行流程:
首先switch中的表达式(值)和case后面值1先进行匹配,如果成立,执行语句1, 遇见break 结束了;
如果不成立,继续判断case 值2和表达式(值)是否匹配,如果成立,执行语句2,break,结束;
如果还不成立,继续依次判断case 后面的值是否匹配…
如果上面的case都不匹配,那么执行default中的语句,遇见break 结束!
switch语句中的注意事项
1)case语句的后面只能是常量,不能是变量
2)关于break的意思: 结束,中断*
switch语句的结束条件
(1) 遇见break结束!
(2) 程序默认执行到末尾!
3)default语句可以放在switch语句中的任何位置,不影响程序的流程,但是
如果在语句中,break不能省略的,如果在末尾,break 可以省略!
4)如果default语句在语句中,break语句不能省略,否则造成case穿透现象!(没有遇见break,不会和case进行比较,直接依次执行)
2.for循环
for循环的格式
for(初始化语句;条件判断语句;步长语句(控制体语句)){
循环体语句;
}
流程:
1)先执行初始化语句对变量进行赋值(只执行一次)
2)判断条件语句是否成立,如果成立,执行 循环体语句
3)执行步长语句(++,–)
4)继续判断条件是否成立,如果还成立, 执行 循环体语句
5)继续执行步长语句(++,–)
…
…
n)当前条件不成立,for循环结束
3.while循环
while循环的格式
基本格式
while(条件表达式){
循环体语句;
控制体/步长语句;
}
扩展格式
初始化语句;
while(条件判断语句){
循环体语句;
控制体/步长语句;
}
流程:
初始化语句执行一次
判断条件是否成立,成立,则执行循环体,再依次执行步长语句;
…
如果不成立,while循环语句结束!
while和for的区别
1)格式不同
2) 并且从内存角度考虑:
for循环的 格式: for循环语句外面不能够访问变量的,因为它随着for循环执行完毕,main方法结束之后,变量就会被GC(垃圾回收器)回收掉这些变量
while循环的扩展格式:循环结束,依然可以访问变量; 在内存中占用资源空间大于for循环
3)如果明确循环次数,优先使用for
不明确循环次数,使用while循环
break的使用场景:
switch语句中,循环语句中使用
while和for的区别
1)格式不同
2) 并且从内存角度考虑:
for循环的 格式: for循环语句外面不能够访问变量的,因为它随着for循环执行完毕,main方法结束之后,变量就会被
GC(垃圾回收器)回收掉这些变量
while循环的扩展格式:循环结束,依然可以访问变量; 在内存中占用资源空间大于for循环
3)如果明确循环次数,优先使用for
不明确循环次数,使用while循环
在程序中出现—死循环
在循环的过程中,没有控制变量,导致程序中永远"恒成立"
for(;;){
语句;
}
while(true){
语句...
}
4.do-while循环
do-while循环
格式
初始化语句;
do{
循环体语句;
步长语句/控制体语句;
}while(条件表达式) ;
流程:
初始化语句执行一次,对变量进行赋值
执行循环体语句,
执行步长语句(++或者–)
判断while后的条件是否成立,成立,继续执行循环体语句…
不成立,语句结束!
do-while循环和for循环以及while循环的最大的区别就是:循环体至少执行一次!
//控制台输出5次"helloworld"
// int i = 1 ;
int i = 6 ;
do{
System.out.println("helloworld") ;
i++;
}while(i<=5) ;
}
5.for循环嵌套
-
for(初始化语句;条件表达式;步长语句){ -
//内层循环是外层循环的循环体语句 -
for(初始化语句;条件表达式;步长语句){ -
循环体语句; -
} -
}
将内层循环看成是外层循环的循环体语句;
需求:
控制台输出形(4行5列的*)
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() ;
}
6.跳转控制语句
break :中断,结束
continue : 继续(循环中使用,结束当前循环,立即进入下一次循环)
return :结束方法(和方法相关)
break
break :单独不能使用
1)在循环中和switch中用
循环中:
单层循环中使用
2) for循环嵌套中使用
标签语句
在外层循环
和内层循环的外面使用 标签名:外层循环/内层循环
break 后面跟标签名称;
3行3列的*
* wc:for(int x = 0 ; x < 3 ; x ++){
* nc:for(int y = 0 ; y <3 ; y ++){
*
* }
*
* }
*
*/
public class BreakDemo {
public static void main(String[] args){
//break ; //单独使用不了
/* for(int x = 0 ; x < 10 ; x ++){
if(x == 3){
break ; //单层循环中使用
}
System.out.println(x) ; //0,1,2,
}*/
//for循环的嵌套:3行4列的*
//带标签的语句:很少用(了解)
wc:for(int x = 0 ; x < 3 ; x ++){
nc: for(int y = 0 ; y < 4 ; y++){
if(y==2){
//break wc ; //break 标签名称;
break nc; //结束内层循环
}
System.out.print("*");
}
System.out.println() ;
}
System.out.println("----------------------------") ;
System.out.println("over") ;
}
}
continue
continue : 继续(循环中使用,结束当前循环,立即进入下一次循环)
*
-
应用场景:循环中使用
面试题
补全空白处代码
for(int x =1 ; x <=10 ; x ++){
* if(x % 3== 0){
* ____补全代码______
* }
* System.out.println("Java基础班") ;
* }
* 需求:
* 1)想在控制台输出输出2次"Java基础班"
* break
* 2)想在控制台输出7次"Java基础班"
* continue
* 3)想在控制台输出13次"Java基础班"
* System.out.println("Java基础班") ;
*/
public class ContinueDemo {
public static void main(String[] args){
//一个for循环
for(int x = 1 ; x <= 10 ; x ++){
// if(x == 3){
if(x % 3 ==0){
continue;//结束当前循环,立即进入下一次循环
}
System.out.println(x) ;
//1,2,4,5,7,8,10
//0,1,2,4,5,6,7,8,9
}
System.out.println("over") ;
}
}
- return
return:要结合方法使用的,一般很少单独使用
```java
public class ReturnDemo {
public static void main(String[] args){
System.out.println("程序开始了..") ;
for(int x = 0 ; x <10 ;x ++){
if(x == 2){
System.out.println("中途退出了...") ;
//break ;
// continue;
return ; //方法终止了!
}
System.out.println(x) ; //0,1
}
System.out.println("voer,结束了...") ;
}
7.方法
在Java中什么是方法呢?
方法 (一个独立的代码块{}):将共性内容抽取出来,使用{}包裹起来,为{}起名字 举例:
植物大战僵尸—豌豆芽–发送炮弹
发送炮弹(是一个程序)要在任何地图上都要使用,给发送炮弹这个程序 抽取出来
给独立起一个名字使用{}将代码包裹起来 ,将名字–方法名,每次 "发送炮弹"地方,只需要调用方法名即可!
重点:
如何定义一个方法
第一种格式:有具体返回值(数据类型)的方法
形式参数列表
权限修饰符 + 静态修饰符 + 具体的返回值类型 + 方法名(数据类型1 变量名1 ,数据类型2 变量名2 ,....){
//完成的业务逻辑
return 结果;
}
详细解释:
-
权限修饰符 :public -
静态修饰符:static(带上) -
具体的返回值类型:数据类型 (目前学习过的基本类型:没有告诉什么类型,都是默认int) -
方法名: 符号 标识符的规则: 小驼峰命名法: -
一个单词:字母全部小写 -
多个单词:第一个单词小写,从第二个单词开始:每个单词首字母大写 形式参数列表: 数据类型1(目前学习过的基本类型:没有告诉什么类型,都是默认int) + 参数名1(变量名) , 数据类型2 参数名2.. return :结束方法: 必须返回具体结果;
定义方法有两个明确:
1)明确返回值类型
2)明确参数类型以及参数个数
调用方法:
1)单独调用:(没有输出)没有意义
2)输出调用:输出:写死了,不利于值的进一步操作
3)赋值调用(推荐)
定义方法的注意事项:
1)方法与方法是平级关系 ,不能再一个方法中定义另一个方法 (不能再方法中定义)
2)Java是强类型语言 (语法结构非常严谨) 弱类型语言:前端:javascript (定义方法:不需要携带数据类型)
定义形式参数:必须携带数据类型
3)调用方法的时候
数据类型 变量名 = 方法名(实际参数列表) ;实际参数如果定义了,传递参数,不需要携带类型
4)目前我们定义的方法都是有方法体的 (有左大括号"{ 的地方不能有分号; 有分号;的地方不能有左大括号"{" )
权限修饰符 + 静态修饰符 +返回值类型 +方法名(形式参数列表){
}
没有具体返回值类型的方法定义以及如何调用
Java语法规定:当一个方法没有具体返回值类型的时候,使用void 代替
2)方法的重载
Java提供一个技术:方法重载 (overLoad)
含义:
多个方法的方法名相同,参数列表不同,与返回值无关 —将这些方法称为"方法重载" ------- 面向对象部分:(继承) 方法重写(override)
参数列表不同有两种情况
1)参数个数不同 (参数类型一致)
2)参数类型不一致(参数个数一致)
8.数组概述
数组是存储多个变量(元素)的东西(容器)
这多个变量的数据类型要一致
数组概念
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
数组定义的格式
格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];
1:针对数组定义两种格式，推荐使用第一种格式。因为第一种的可读性更强。
*注意：这两种定义做完了，数组中是没有元素值的。
数组的初始化
数组初始化概述
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
动态初始化
初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例：
int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
引用类型:一旦对象创建了,地址值永远固定,除非重新new 新的对象,才产生一个新的地址!
Java中的内存分配
Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，
因为每一片区域都有特定的处理数据方式和内存管理方式。
栈 存储局部变量
堆 存储new出来的东西
方法区（面向对象部分讲）
本地方法区（和系统相关）
寄存器（给CPU使用）
1：局部变量
a:方法定义中或者方法声明上的所有变量
b:使用完毕，立即消失2：new出来的东西，实体，对象。
new int[3];
a:每一个实体都有首地址值
b:每一个实体内的数据都有默认值
byte,short,int,long 0
flfloat,double 0.0
char ‘\u0000’
boolean false
引用类型：null
c:使用完毕后，会被垃圾回收器空闲的时候回收。
其实讲解完堆和栈的区别，大家就能够理解刚才为什么输出的是地址和0了。
静态初始化
初始化时指定每个数组元素的初始值，由系统决定数组长度。
格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例：
int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
其实这种写法还有一个简化的写法
int[] arr = {1,2,3};
注意事项:
int[] arr = new int[5]{11,22,33,44,55} ;
//错误的:数组初始化只能有一种:不能既动态初始化,又静态初始化
数组中常见的两个小问题
数组索引越界
ArrayIndexOutOfBoundsException
访问到了数组中的不存在的索引时发生。
出现错误的原因:
开发者在书写代码的时候导致,角标值超出了数组的长度
解决方案: 只要正常访问角标值就可以
空指针异常
NullPointerException
数组引用没有指向实体，却在操作实体中的元素时
出现的原因:
某个对象(数组)已经为null了,堆内存中没有空间地址值了,开发者还试图访问这个对象(数组)中的元素,就会有问题
解决方案:
针对对象:进行逻辑判断
如果对象不为null,再去访问;
将一个数组进行逆序排列
/**
*定义一个逆序的方法
* 两个明确:
* 1)明确返回值类型:void (没有具体返回值类型)
* 2)明确参数类型以及参数个数
* int类型的数组,1个参数
*
*
* int a= 10 ;
* int b = 20 ;
* 交互a,b的值
*/
public static void reverse(int[] arr){//数组
//第一次互换
//中间变量 (开发中常用)
/*int temp = arr[0] ;
arr[0] = arr[arr.length-1-0] ;
arr[arr.length-1-0] = temp ;
//第二次互换
temp = arr[1] ;
arr[1] = arr[arr.length-1-1] ;
arr[arr.length-1-1] = temp ;*/
//第三次互换
//..
//...
// 保证当前元素的范围:角标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 ;
}
}
//遍历的功能
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]+", ") ;
}
}
}
查询数组角标的方法
//定义一个数组,静态初始化
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);
}
9.面向对象
前面我们讲过数组，当有多个数组都需要遍历时，我们可以将遍历的代码封装到方法中，需要遍历时，就调用相应
的方法即可，提高代码的复用性。在对数组遍历的基础上继续增加需求，比如获取最值，数值逆序等，同样需要将
这些功能封装到相应的方法中。这样继续封装会发现方法越来越多，于是就想能不能将这些方法继续进行封装呢？
通过前面的讲解我们知道类是可以存放方法的，所以，我们就考虑使用类封装来这多个方法，将来再做数组的操作
时，不用去找具体的方法，先找到这个类，然后使用这个类中的方法。这就是面向对象思想的编程方式。
面向对象思想概述以及特点
思想概述:
面向对象是基于面向过程的编程思想
特点：
1.是一种更符合我们思想习惯的思想
2. 可以将复杂的事情简单化
3. 将我们从执行者变成了指挥者角色发生了转换
面向对象思想举例
买电脑
吃饭
洗衣服
万事万物皆对象
类与对象关系
我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。 我们如何表示一个现实世界事物呢： 属性 就是该事物的描述信息 行为 就是该事物能够做什么
举例：学生事物 我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
类与对象关系
类：是一组相关的属性和行为的集合
类—Java中的最基本单元
对象：是该类事物的具体体现(应该是指定的某个类中具体的事物)
类的定义
现实世界的事物 属性 人的身高，体重等 行为 人可以学习，吃饭等Java中用class描述事物也是如此
成员变量: 就是事物的属性
成员方法: 就是事物的行为 定义类其实就是定义类的成员(成员变量和成员方法)
1:成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
2:成员方法 和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
面对对象的基本特点
面向对象本质就是基于面向过程:
面向过程:代表语言就C语言
需求:给定义数组,获取数组中的最大值
1)创建数组
2)遍历数组
3)业务逻辑判断
假设法(定义一个参照物是最大值)
遍历数组时候,将后面的元素依次和它比较
如果后面的元素比它大,后面的元素就是最大值
4)输出结果...
面向对象:代表就是Java
生活中的例子:
买电脑:
面向过程:
1)制定自己的需求(什么的电脑配置)
2)去赛格电脑城
3)讨价还价
4)支付价钱
5)买到电脑
面向对象:
1)制定自己的需求(什么的电脑配置)
2)找一个懂行的朋友(面向过程)
3)他给我买到电脑
做饭
面向过程:
1)买菜
2)讨价还价
2)摘菜
4)洗菜
5)切菜
6)炒菜
7)出锅...
面向对象:
1)找一个对象
2)等待出锅..
洗衣服:
面向过程:
1)脱下脏衣服
2)找一个盆
3)加入洗衣液_水
4)将衣服泡一泡
5)搓一搓
6)透一透
7)拧一拧
8)晾一晾...
面向对象:
1)脱下脏衣服
2)全自动洗衣机
3)一键完成..
生活中处处皆对象...
面向对象的思想特点:
1)更符合生活中的思想行为习惯
2)将复杂的事情简单化
3)让我们从执行者变成指挥者(角色发送变化了)
Java语言的面向对象特征:
封装,继承.多态!
Java面向对象语言设计原则:
可以不断的创建对象,使用对象,然后指挥对象做事情!
键盘录入数据:
Scanner类 ---- 完成对象 的创建以及录入的数据
需求:
将大象装进冰箱!
伪代码
面向过程:一步一步分析,一步一步完成
测试类:Demo
class Demo{
public static void main(String[] args){
open() ;//开冰箱门
in() ;//将大象装进去
close() ;//关闭冰箱门
}
/*
定义冰箱开门的功能
*/
public static void open(){
输出---"打开冰箱门"
}
/*
定义一个大象进去的功能
*/
public static void in(){
输出---"将大象装进去"
}
/*
定义冰箱关门的功能
*/
public static void close(){
输出---"关闭冰箱门"
}
}
面向对象: Java语言:中 ---最基本的单元是类
将大象装进冰箱!
1)分析有哪些类
2)类中有什么东西
大象类---进去的功能
冰箱--- 开门和关门的功能
测试类---main方法---主程序(程序的入口)
分析:UML :名词提前法
大象----大象类
冰箱----冰箱类
测试类:Demo
class 大象类{
public static void in(){
System.out.println("大象进去...") ;
}
}
class 冰箱类{
public static void open(){
System.out.println("打开冰箱门") ;
}
public static void close(){
System.out.println("关闭冰箱门") ;
}
}
测试类:Demo
class Demo{
public static void main(String[] args){
//能够创建冰箱类对象
冰箱类对象.open() ;
//如果能够创建大象类对象
大象类对象.in() ;
冰箱类对象.close() ;
}
}
类与对象的关系
类---Java中的最基本单元
描述现实世界事物的属性和行为的集合!
描述现实世界真是存在的事物:
分析:
学生事物
属性:姓名,年龄,身高,性别
行为: 学生 主要学习
学生可以玩游戏(会玩高端:吃鸡游戏/steam:战地/....)
将上面的分析真实存在的事物-----变成Java代码(程序方式描述)
学生类 (统称)
将事物的属性-----成员变量(类中,方法外)
(name,age,high,gender)
将事物的行为-----成员方法(和我们之前学习的方法是一样的,去掉static)
public 有返回值类型 方法名(形式参数列表){
return 结果;
}
public void 方法名(形式参数列表){
输出...
}
类和对象的关系
对象:应该是指定的某个类中具体的事物
学生事物
张三
李四
class Student{
//定义成员变量 (学生事物的属性)
//定义成员方法(学生事物的行为)
}
//测试类中
对象:描述具体事物
创建对象的格式:
类名 对象名 = new 类名() ;
Student s = new Student() ;
//给学生赋值:姓名,年龄,身高,性别
对象名称.成员变量= 赋值;
//使用学生的行为:访问成员方法
对象名.方法名() ;
匿名对象
匿名对象：就是没有名字的对象。
是对象的一种简化表示形式
匿名对象的两种使用情况
对象调用方法仅仅一次的时候
作为实际参数传递
匿名对象:顾名知意: 没有名字的对象
类名 对象名 = new 类型() ; 有名字的对象
//1:new Student().show();
//2:new StudentTest().method(new StudentDemo());
匿名对象的格式:
new 类名() ;
new 类名().成员方法名() ; 访问当前类中的成员方法
特点:
1)匿名对象:使用完毕,会立即垃圾回收器回收,节省内存空间!
应用场景:都是在移动端使用居多—Android :基于Java (大部分都是使用匿名对象,节省内存)
2)开发中,匿名对象使用一次即可,不要使用多次! (使用完毕,就立即被回收)
3)匿名对象可以作为参数传递
封装
Java提供一个关键字:private 封装
封装概述
封装概述
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
封装原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
/**
* 需求:
* 学生事物,
* 属性:姓名,年龄,性别
* 行为:学习,爱好...
*
* 使用Java程序描述学生事物并且进行测试
*
* 注意:
* 同一个包下(文件夹)不能存在同一个类名
*
*
*
*
*/
class Student2{
//成员变量私有化
private String name ; //姓名
private int age ; //年龄
private String sex ;//性别
//对外提供成员变量的公共的访问
//setXXX(xxx):赋值
//getXXX():获取值
//给姓名赋值 的成员方法
public void setName(String n) { //"高圆圆"
name = n ; //name = "高圆圆"
}
//获取name的成员方法
public String getName(){
return name ; //"高圆圆"
}
//给年龄赋值
public void setAge(int a){ //a=23
age = a ;//23
}
//获取年龄的值
public int getAge(){
return age ;//23
}
//给性别赋值
public void setSex(String s){//s="女"
sex = s ;
}
//获取性别
public String getSex(){
return sex ; //"女"
}
//成员方法
public void study(){
System.out.println("学习JavaEE...");
}
//爱好
public void hobit(){
System.out.println("爱生活,爱Java...");
}
}
//测试类
public class StanderClass {
public static void main(String[] args){
//创建一个具体的对象:
//类名 对象名 = new 类名() ;
Student2 s = new Student2() ;
//给成员变量
/* s.name = "高圆圆";
s.age = 23 ;
s.sex = "女" ;*/
//name,age,sex 三个属性已经私有化了,只能本类中访问,外界不能访问
//外界访问----通过公共的访问方法来访问:
//提供公共访问
s.setName("高圆圆");
s.setAge(23);
s.setSex("女");
// System.out.println(s.name+"---"+s.age+"----"+s.sex);
System.out.println("学生的姓名是:"+s.getName()+",年龄是:"+s.getAge()+",性别是:"+s.getSex());
s.study();
s.hobit();
}
}
关键字
1)private关键字
private关键字：
是一个权限修饰符。
可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。
private最常见的应用：
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
一个标准的案例的使用
2)this关键字
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...");
}
}
标签：总结,语句,arr,int,JAVA2011,第二周,数组,public,循环 来源： https://blog.csdn.net/pzl15151/article/details/112391500
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。