week02
day05
1.Switch语句
1.switch(表达式){}
跟的基本类型:byte,short,int,char
使用的注意事项:
1).case语句后面的值:在java中,只能是常量
2).default语句可以在Switch语句中的任何位置,不影响Switch执行流程
如果在语句中:break不建议省略,否则case穿透
如果在语句末尾:break可以省略
3).语句break结束;(没有break,case穿透)
程序默认执行到末尾
/*
键盘录入月份的值,使用switch语句,判断季节
3,4,5---春季 6,7,8----夏季 9,10,11----秋季 12,1,2---冬季
1)创建键盘录入对象
2)录入数据
3) switch(month){
case穿透:
case 3:
case 4:
case 5:
break;
}
if...else 和Switch ; 优先采用Switch语句
*/
import java.util.Scanner; //导包
class SwitchTest{
public static void main(String [] args){
Scanner sc = new Scanner(System.in); //键盘录入对象
System.out.println("请您输入一个月份的值:");// 提示并录入数据
int month = sc.nextInt();
//使用Switch语句接收数据
switch(month){
case3:
case4:
case5:
System.out.println("春季");
break;
case6:
case7:
case8:
System.out.println("夏季");
break;
case9:
case10:
case11:
System.out.println("秋季");
break;
case12:
case1:
case2:
System.out.println("冬季");
break;
default:
System.out.println("对不起,没有此月份");
break;
}
}
}
2.for语句
循环语句之for的格式
for(初始化语句;条件表达式;步长/控制体语句){
循环体语句;
}
执行流程:
1)执行初始化语句,给变量赋值
2)满足条件:成立
3)执行循环体语句
4)执行步长/控制体语句
再次执行2)过程,判断条件是否成立
依次循环
...
当条件表达式不成立,则for语句结束;
/*
水仙花数:一个三位数,每一个位上的数据的立方之和是当前数据本身
153 = 1*1*1+5*5*5+3*3*3
//定义三个变量
int ge = x % 10;
int shi = x / 10 % 10;
int bai = x / 10 / 10 % 10;
*/
class ForDemo{
public static void main(String[] args){
//水仙花数:范围 100~999之间
for(int x = 100;x<1000;x++){
int ge = x % 10;
int shi = x /10 % 10;
int bai = x / 10 / 10 % 10;
if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)){
System.out.println("水仙花数是:"+x);
}
}
}
}
3.循环语句之while /dowhile
while格式:
初始化语句;
while(条件表达式){
循环体语句;
控制体语句;
}
循环的执行流程:
1)初始化语句进行赋值
2)条件表达式成立
执行循环体语句
再次执行控制体语句
3)再次判断条件表达式是否成立
...
...
当条件不成立,则while结束
dowhile格式:
初始化语句;
do{
循环体语句;
控制体语句;
}while(条件表达式);
dowhile:优先循环体语句,即使条件不成立,循环体至少执行一次!
在jdk提供的某些原码中可以看到dowhile循环
/*
输入一个整数,计算它各位上数字的和(注意:任意位的整数)
*/
import java.util.Scanner; //导包
class WhileTest{
public static void main(String[] args){
Scanner sc = new Scanner(System.in); //创建键盘录入对象
System.out.println("请您输入一个数据n:"); //提示并录入对象
int n = sc.nextInt();
//各位数字使用%取之相加,取十位/ ,再次进入循环
int sum = 0; //定义最终结果变量
while(n!= 0){ //循环判断
sum += n % 10; //取个位 sum = sum +(n % 10);
n = n/10; //取十位,去除低位
}
System.out.println("各位和:"+sum);
}
}
//while循环 1~100 的奇数和
class WhileTest2{
public static void main(String[] args){
int m = 1;
int sum2 = 0;
while(m<=100){
if(m % 2 != 0){
sum 2 += m;m++;
}else{
m++;
}
}
System.out.println("1~100的奇数和是:"+sum2);
}
}
3.for和while的区别
for和while的区别 (开发中,优先使用for,其次while,最后dowhile)
1).从格式上来讲:格式不同
for(初始化语句;条件表达式;控制体语句){
循环体语句;
}
初始化语句;
while(条件表达式){
循环体语句;
控制体语句;
}
for循环结束之后,不能在访问for中变量,for循环结束;变量需要被释放;
while循环可以访问;
2).内存:for循环节省内存空间
堆,栈内存(存储局部变量:在方法定义中或者方法声明上的变量);
for循环结束,变量随着被释放掉,节省内存空间;(不能访问这个变量)
while循环结束,依然可以访问这个变量,比较消耗内存空间;
3).使用场景:
for循环:明确循环次数
while循环:不明确循环次数使用
4)死循环
/*
猜数字游戏:
1).产生一个1~100之间随机数:num
用户不断录入数据
while(true){ }
2).创建键盘录入对象
3).提示并录入数据 guessNumber
4).多种情况进行判断:if...else if...else
*/
import java.util.Scanner;
class GuessNumGame{
public static void main(String[] args){
int count = 0; //定义一个统计变量
int num = (int)(Math.random()*100+1); //定义一个1~100之间的随机数
while(true){
Scanner sc = new Scanner(System.in); //创建键盘录入对象
count ++; //统计变量++
System.out.println("请您输入一个数据:"); //提示并录入数据
int guessNumber = sc.nextInt();
if(guessNumber>num){
System.out.println("您猜的数字大了...");
}else if(guessNumber<num){
System.out.println("您猜的数字小了...");
}else{
System.out.println("恭喜您,中奖了");
}
}
}
}
5)for循环嵌套
for循环嵌套:一个for循环语句作为另一个for循环语句的循环体
for(初始化语句;条件表达式;控制体语句){
for(初始化语句;条件表达式;控制体语句){
}
}
/*
（for 循环）“百钱买百鸡”是我国古代的著名数学题。题目这样描述：3 文
钱可以买1只公鸡，2 文钱可以买一只母鸡，1 文钱可以买3 只小鸡。用100 文
钱买100 只鸡，那么各有公鸡、母鸡、小鸡多少只？
穷举法:
设公鸡为x，母鸡为y，小鸡为z
x+y+z = 100;
5x+3y+z/3 = 100;
x,y,z的取值范围:5x<100------> 0 < x <20;
0<y<33;
z=100-x-y;
*/
class ChickenTest{
public static void main(String[] args){
for(int x = 1;x<20;x++){
for(int y = 1;y<33;y++){
int z =100-x-y;
if((z %3==0) && (x*5+y*3+z/3==100)){
System.out.println("公鸡的数量为:"+x+",母鸡的数量是:"+y+",小鸡的数量为:"+z);
}
}
}
}
}
-----------------------------------------------------------------
//99乘法表
class ForForDemo{
public static void main(String[] args){
for (int x = 1;x<=9;x++){
for(int y = 1;y<=x;y++){
System.out.print(x+"*"+y+"="+(x*y)+"\t");
}
System.out.println();
}
}
}
6)跳转控制语句
三个关键字:
break:结束中断,结束循环(不能单独使用), 在Switch和循环语句中使用(for/while...使用居多)
return:很少单独使用,结合有具体返回值类型的方法使用;(结束方法)
continue:继续,在循环中使用,结束当前循环,立即进入下一次循环
7)方法
使用{}代码块包起来,并且起一个名字(见名知意)
1).有具体返回值类型的方法的定义
固定格式
public static 返回值类型 方法名(参数类型1 变量名1,参数类型2 变量名2...){
......
return 结果;
}
********两个明确:1).明确返回值类型
2).明确参数类型以及参数个数
public:访问权限足够大,公共的
static:静态修饰符
返回值类型:基本数据类型
方法名:小驼峰命名法(见名知意)
参数类型:第一个参数的数据类型
变量名:小驼峰命名法
day06
1.有具体返回值类型的方法的使用
方法使用中的注意事项:
1).方法和方法是平级关系,不能进行嵌套;
在一个方法中定义另一个方法不允许
2).在java中,定义方法的时候形式参数必须携带数据类型;
3).调用方法的时候,传递的实际参数不需要在携带数据类型
4).定义方法的时候:有{括号的地方不能有分号;
有具体返回值类型的调用格式:赋值调用
返回值数据类型 变量名 = 方法名(实际参数列表)
/*
键盘录入三个数据,比较三个数据最大值;
键盘录入两个数据,判断数据是否相等;
键盘录入两个数据,获取最大值
*/
import java.util.Scanner;
class CompareDemo{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请您输入第一个数据:");
int a = sc.nextInt();
System.out.println("请您输入第二个数据:");
int b = sc.nextInt();
System.out.println("请您输入第三个数据:");
int c = sc.nextInt();
//调用获取三个数据最大值的方法
int max = getMax(a,b,c);
System.out.println("三个数据最大值是:"+max);
//------------------------------------------------------------
//键盘录入两个数据,判断数据是否相等
System.out.println("请您输入第一个数据:");
int x = sc.nextInt();
System.out.println("请您输入第二个数据:");
int y = sc.nextInt();
//调用获取两个数据是否相等的方法;
boolean flag = compare(x,y);
System.put.println(flag);
//-------------------------------------------------------------
//键盘录入两个数据,获取最大值;
System.out.println("请输入第一个数据:");
int m = sc.nextInt();
System.out.println("请输入第二个数据:");
int n = sc.nextInt();
//调用获取两个数据最大值的方法;
int result = getResult(m,n);
System.out.println("result:"+result);
}
//--------------------------------------------------------------
/*
定义方法1:三个数据最大值的方法:getMax
两个明确: 1).明确返回值类型:int类型
2).明确参数类型以及参数个数 (参数类型:int 参数个数:2个)
*/
public static int getMax(int a,int b ,int c){ //形式参数
int max;
if(a>b){
if(a>c){
max =a ;
}else{
max=c;
}
}else{
if(b>c){
max = b;
}else{
max = c;
}
}
return max;
}
//------------------------------------------------------------------
/*
定义方法2:比较两个数据是否相等的方法
两个明确:
1).明确返回值的类型:boolean
2).明确参数类型以及参数个数(参数类型:int 参数个数:两个)
*/
public static boolean compare(int a, int b){ //形式参数
boolean flag = (a==b);
return flag;
}
//-------------------------------------------------------------------
/*
定义方法3:比较两个数据最大值的方法
两个明确:
1).明确返回值的类型: int
2).明确参数类型以及参数个数(参数类型:int 参数个数:两个)
*/
public static int getResult(int a ,int b){
int max = (a>b)?a:b;
return max;
}
}
2.没有具体返回值类型的方法的定义以及调用
定义:针对某个功能代码块{}没有具体的返回值类型,java提供了一个关键字"void"代替没有具体返回值类型
固定格式:public static void 方法名(形式参数列表){
.....
}
没有具体返回值类型的方法调用格式:单独调用
//写一个方法，接收一个数据m，输出mm乘法表（预习一下：没有具体返回值类型）
import java.util.Scanner;
class work1{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请您输入一个数x:");
int x =sc.nextInt();
mmNext(x);
}
public static void mmNext(int n){
for(int i=1;i<=n;i++){ //行数
for(int j=1;j<=i;j++){ //列数
System.out.print(i+"*"+j+"="+i*j+"\t");
}
System.out.println();
}
}
}
3.方法重载
方法重载(overload):方法名相同,参数列表不同,与返回值无关
参数列表不同:1).参数个数不同
2).参数类型不同(考虑类型的顺序)
public static void open(int a,double b){}
public static void open(double d, int c){}
目的:就是为了提高某个功能的扩展性
4.数组
数组(最基本的容器):可以储存多个元素的容器,必须保证数据类型一致;(默认值为null)
特点:
1).长度确定;(数组只要被创建,它的大小就是不可以改变的);
2).其基本元素必须是相同类型,不允许出现混合类型;
3).数组类型可以是任何数据类型,包括基本数据类型和引用类型
数组变量属于引用类型,数组本身就是对象,数组中的每个元素相当于该对象的成员变量;
定义格式:
数据类型[] 数组名称;---------int[] arr;
数据类型 数组名称[];-------- int arr[];
1)动态初始化:给定了数组的长度,系统默认对元素进行初始化;(int类型,默认值0)
数据类型[] 数组名称 = new 数据类型[数组长度];
数据类型 数组名称[] = new 数据类型[数组长度];
int[] arr = new int[6];
2)静态初始化:给定数组的元素,系统默认分配长度;
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....};
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....};
简化格式:
数据类型[] 数组名称 = {元素1,元素2,元素3....};
数据类型 数组名称[] = {元素1,元素2,元素3...};
int[] arr = {1,2,4,5};
数组的内存分配
1).寄存器:我们在程序中无法控制;
2).栈内存:存储的是局部变量
3).堆:存放new产生的数据,创建对象,存储成员变量
4).方法区
数组的应用-----遍历
遍历:将数组中的元素一一获取并输出到控制台上
length:获取数组长度
/*
已知数组:静态初始化 int[] arr = {11,22,33,44,55};将数组的元素遍历
*/
class ArrayTest{
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++){
//判断:如果当前x取到最大索引值 arr.length-1
if(x==arr.length-1){
System.out.println(arr[x]+"]");
}else{
//不是最后一个索引值,中间的元素 arr[x]+","不换行
System.out.print(arr[x]+",")
}
}
}
}
5.数组中的内存分配---数组:引用数据类型(默认值为null)
1).main方法进栈,在栈内存开辟空间;
2).栈内存中:开辟某个空间,为数组类型的变量(int[] arr);
3).在堆内存中,申请空间 new int[2]
4).需要通过系统默认对元素内容初始化:元素默认是int类型,默认值都是0;
5).默认初始化完毕,就会为当前new int[2];产生一个堆内存空间地址值:十六进制数据
6).需要将堆内存的地址值赋值给栈内存变量arr,栈内存arr指向堆内存地址值
7).可以显示初始化,给元素内容赋值,将系统默认初始化值覆盖
day07
1.数组的基本应用
1).数组的最值问题:
给定一个数组:静态初始化,获取数组中最大值,最小值
int[] arr = {75,10,24,98,35};
class ArrayTest{
public static void main(String[] args){
int[] arr = {75,10,24,98,35};
}
//调用最大值方法
int result = getMax(arr);
System.out.println("数组中的最大值是:"+result);
//调用最小值方法
int min = getMin(arr);
System.out.println("数组中的最小值是:"+min);
/*定义一个获取数组最大值的方法
1).明确返回值类型:int
2).明确参数类型以及参数个数: int[] arr,1个;
*/
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;
}
/*定义一个获取数组最小值的方法
1).明确返回值类型:int
2).明确参数类型以及参数个数: int[] arr,1个;
*/
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;
}
}
2).数组的逆序问题
定义一个逆序的方法
1).明确返回值类型:没有具体返回值类型 void;
2).明确参数类型以及参数个数 int[] arr,1个参数;
public static void reverse(int[] arr){
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取到最大索引值 arr.length-1
if(x==arr.length-1){
System.out.println(arr[x]+"]");
}else{
//不是最后一个索引值,中间的元素 arr[x]+","不换行
System.out.print(arr[x]+",")
}
}
}
3).数组的查表法:通过数组名称[索引值]来确定元素内容
4).元素的基本查找:在数组中查询某个元素第一次出现的索引值;数组既可以有序,也可是无序的;
(从头到尾:0~arr.length-1)
2.数组高级排序:冒泡排序
冒泡排序思想:两两比较,较大的数值往后放,第一次比较完毕,最大值出现在最大索引处,依次这样比较,可以得到排好序的数组;
核心代码:
/*定义一个冒泡方法
明确返回值类型:没有具体返回值 void
明确参数类型以及参数个数 一个数组
*/
public static void mp(int[] arr){
for(int x = 0;x<arr.length-1;x++){ //外层:比较的次数
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;
}
}
}
}
3.形式参数
方法的形式参数:
1).方法的形式参数是基本数据类型,形式参数的改变不会影响实际参数;
2).方法的形式参数是引用数据类型(数组):
String类型:特殊的引用类型,它作为形式参数,效果和基本数据类型一致,形式参数的改变不影响实际参数
3).方法的形式参数是数组类型(除String类型外)
实际参数传递,传递数组对象,形式参数的改变会直接影响实际参数
4.面向对象
面向对象基于面向过程
思想特点:
1).更符合我们生活中的思想行为习惯;
2).让复杂的事情简单化;
3).从执行者变成了指挥者;
面向对象:"万物皆对象"
设计宗旨:在开发中,需要不断的创建对象,使用对象,指挥对象完成一些事情
三大特征:封装:即把能够实现功能的函数写成封装起来，在面向对象里叫做方法。
简单来说就是把实现功能的函数写成方法
继承:在实现同一种功能的前提下，新对象可以使用就对象的属性和方法
多态:一个变量在引用不同类型的情况下的不同状态。
/*
使用面向对象的方式描述现实世界的"手机事物"
定义手机类
属性: 品牌(brand) ,价格(price),颜色(color),内存(memory)
行为:打电话,发短信,玩游戏,学习
*/
class Phone{
String brand ;//品牌
int price ; //价格
String color; //颜色
String memory; //内存
public void call(){
System.out.println("打电话");
}
public void playGame(){
System.out.println("玩游戏");
}
public void sendMessage(){
System.out.println("发信息");
}
public void study(){
System.out.println("用来学习");
}
}
class PhoneDemo{
public static void main(String[] args){
Phone p = new Phone();
p.brand = "荣耀";
p.price = 6666;
p.color = "blue";
p.memory = "128G";
System.out.println("手机品牌是:"+p.brand+",价格:"+p.price+",颜色:"
+p.color+",内存:"+p.memory);
p.call();
p.playGame();
p.sendMessage();
p.study();
}
}
5.类与对象的关系
类:能够描述现实世界真实事物的一组属性和行为的集合!-----事物(属性和行为);
事物中的属性-----类中:成员变量
事物中的行为-----类中:成员方法 去掉static关键字
类名 对象名 = new 类名();
对象名.属性名(成员变量) = 赋值;
对象名.行为(成员方法名())
对象:客观存在的具体的事物;
day08
1.成员变量和局部变量的区别
1).在程序中的书写位置不同
局部变量:方法定义中或者方法声明上;
成员变量:在类中,成员方法外定义的变量;
2).在内存中
局部变量:在栈内存中;
成员变量:在堆内存中;
3).生命周期不同
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失;
成员变量:随着对象的创建而存在,随着对象创建完毕,等待立即回收器回收对象才能消失;
4)初始化不同:
局部变量: 无论是先定义还是直接初始化,必须在使用之前初始化,否则报错!
成员变量:在堆内存中由系统默认初始化(根据成员变量的类型进行默认初始化:String:null int:0)
2.方法的形式参数是引用类型---具体类,实际参数的传递
//方法的形式参数:引用类型:数组,类,接口
//如果是一个具体类,在调用方法的时候,实际参数需要传递的是当前类的对象
//学生类
class Student{
public void study(){
System.out.println("学无止境");
}
}
//定义一个StudentDemo类
class StudentDemo{
public void method(Student s){ //形式参数是具体类
s.study(); //形式参数.方法名();
}
}
//测试类
class StudentTest{
public static void main(String[] args){
//需要调用StudentDemo类中的method方法
//创建StudentDemo类对象
StudentDemo sd = new StudentDemo();
//创建一个具体的学生对象
Student student = new Student;
sd.method(student);
}
}
3.匿名对象
定义:就是没有名字的对象
格式: new 类名();
特点:匿名对象可以作为参数传递,而且它在开发中使用一次就可以,只在堆内存开辟空间,使用完毕,被回收!
class Student{
public void study(){
System.out.println("学无止境");
}
}
class StudentDemo{
public void method(Student student){
student.study();
}
}
class NoNameDemo{
public static void main(String[] args){
StudentDemo sd = new StudentDemo();
Student s = new Student();
sd.method(s);
System.out.println("-------------------");
StudentDemo sd2 = new StudentDemo();
sd2.method(new Student());
System.out.println("--------------------");
new StudentDemo().method(new Student());
}
}
4.封装
封装:就是将一个类(能够描述现实世界事物)的属性细节隐藏(成员变量私有化),保证数据的安全性,
对外提供公共的访问方法
class Student{
//属性私有化
private String name; //姓名
//对外提供公共的访问方法
//给学生的姓名赋值;
public void setName(String n){
name = n;
}
public String getName(){
return name;
}
}
5.private关键字
private 关键字 权限修饰符的一种
特点:1).可以修饰成员变量,也可以修饰成员方法,但是都只能在本类访问,外界不能够访问
2).这些被私有修饰符的成员变量,或者成员方法,可以间接通过公共方法来访问
权限修饰符:
private:私有的,只能本类访问
protected: 受保护的
public : 公共的,访问权限足够大,任何情况下都能访问!
day09
1.this
this:代表的当前类对象的地址值引用(局部变量隐藏了成员变量,通过this区分)
this.变量名: 访问的本类的成员变量
this.方法名():访问的是本类的成员方法
this() :访问本类无参构造方法
this(String xx):访问本类的有参构造方法
/*
学生事物
属性:姓名,年龄,性别
行为:学习,抽烟..
学生类描述学生事物----加入封装思想并加入this关键字
*/
class Student{
//属性私有化
private String name; //姓名
private int age; //年龄
private String gender; //性别
//无参构造方法
public Student(){}
//有参构造方法
public Student(String name,int age,String gender){
//赋值
this.name = name;
this.age = age ;
this.gender = gender;
}
//提供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;
}
//给性别赋值
public void setGender(String gender){
this.gender = gender;
}
//获取性别
public String getGender(){
return gender;
}
public void study(){
System.out.println("好好学习,天天向上");
}
public void smoke(){
System.out.println("抽烟");
}
}
class StudentTest{
public static void main(String[] args){
Student s = new Student();
s.setName("张晓明");
s.setAge(20);
s.setGender("男");
System.out.println("姓名是:"+s.getName()+",年龄:"
+s.getAge()+",性别是:"+s.getGender());
s.study();
s.smoke();
}
}
2.类的初始化过程
Student s = new Student()完成的事情:
1).加载Student.class字节码文件;类就加载一次
2).在栈内存中Student类型的s变量开辟栈内存空间;
3).在堆内存中申请空间地址;
4).在堆内存中给Student类的所有成员进行默认初始化;
5).然后再通过构造方法进行数据初始化;
6).默认初始化完毕,产生一个堆内存空间地址;
7).将堆内存空间地址值赋值给栈内存的这个变量;
8).栈内存的变量s指向堆内存地址
3.构造方法
构造方法:
1).构造方法名和类名一致
2).没有具体的返回值类型
3).连void都没有
目的:为了给类的成员的一些数据进行初始化(给当前类的成员变量进行数据初始化操作)
构造方法的使用注意事项:
1).当书写类的时候,没有提供任何构造方法,系统默认提供无参构造方法;
2).一旦我们提供了有参构造的方法,没有提供无参构造方法,系统不会在默认提供无参构造方法,此时如果继续用无参构造方法创建对象就会报错,永远建议给出无参构造方法!
给成员变量赋值有两种方法:
1).提供公共的访问方法:setXXX()
2).构造方法
class Student{
//成员变量
int age ;
//无参构造方法
public Student(){}
//有参构造方法
public Student(int age){
this.age = age ;
}
}
/*练习:定义一个笔记本类，该类有颜色（char）和cpu型号（int）两个属性。
1) 无参和有参的两个构造方法；有参构造方法可以在创建对象的同时为每个属性赋值；
2) 输出笔记本信息的方法
3) 然后编写一个测试类，测试笔记本类的各个方法
*/
class Computer{
//两个属性
private char color;
private int cpu;
//无参构造方法
public Computer(){}
//有参构造方法
public Computeer(char color,int cpu){
this.color = color;
this.cpu = cpu;
}
//提供setXXX()/getXXX()赋值,获取信息
public void setColor(char color){
this.color= color;
}
public char getColor(){
return color;
}
public void setCpu(int cpu){
this.cpu = cpu;
}
public int getCpu(){
return cpu;
}
//输出笔记本信息的方法
public void showComputerMsg(){
System.out.println("笔记本的颜色是"+color+",型号为:"+cpu);
}
}
测试类
class Test{
public static void main(String[] args){
Computer computer = new Computer('s',100);
computer.showComputerMsg();
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
