java学习第二周周记

JAVA学习第二周周记

**day1.**流程控制语句，跳转控制语句
**day2.**什么是方法？方法的重载
**day3.**数组，栈和队列
**day4.**冒泡排序及对象的引入
**day5.**封装，this关键字

#day1#**
1.选择结构语句之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后面的表达式可以是什么样的数据类型?

```
 最基本的:byte,short,int,char
```
```
 JDK5以后可以是枚举类型
```

 JDK7以后可以是String类型 (引用类型)

swtich语句中的注意事项：

 1)case语句的后面只能是常量,不能是变量

```
 2)关于break的意思: 结束,中断
```
```
 switch语句的结束条件
```
```
     (1) 遇见break结束!
```
```
     (2) 程序默认执行到末尾!
```

 3)default语句可以放在switch语句中的任何位置,不影响程序的流程,但是

 如果在语句中,break不能省略的,如果在末尾,break 可以省略!

4)如果default语句在语句中,break语句不能省略,否则造成case穿透现象!(没有遇见break,不会和case进行比较,直接依次执行)

编程案例：

//键盘录入一个数据(int),判断当前是星期几
import java.util.Scanner;//键盘录入一个数据(int),判断当前是星期几
public class Switch {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… for循环
. 格式：
*

 for(初始化语句;条件判断语句;步长语句(控制体语句)){

```
     循环体语句;
```
```
 }
```
```
 流程:
```

 1)先执行初始化语句对变量进行赋值(只执行一次)

 2)判断条件语句是否成立,如果成立,执行  循环体语句

```
 3)执行步长语句(++,--)
```

 4)继续判断条件是否成立,如果还成立, 执行  循环体语句

```
 5)继续执行步长语句(++,--)
```
```
 ...
```
```
 ...
```

 n)当前条件不成立,for循环结束

经典for循环面试题：
（1）打印水仙花数：

public class For5 {public static void main(String[] args) {for (int i = 100; i < 1000; i++) {if (((i % 100 / 10) * (i % 100 / 10) * (i % 100 / 10) + (i % 10) * (i % 10) * (i % 10) + (i / 100) * (i / 100) * (i / 100)) == i){System.out.println(i);}}}
}

（2）百钱买百鸡：

public class For2 {public static void main(String[] args) {for (int i = 0; i <=33; i++) {for (int j = 0; j <=50; j++) {int k=100-i-j;if(k%3==0&&(3*i+2*j+k/3==100)){System.out.println("公鸡："+i+"母鸡："+j+"小鸡："+k);}}}}
}

3.while循环
while循环的格式

```
 基本格式
```
```
 while(条件表达式){
```
```
     循环体语句;
```
```
     控制体/步长语句;
```
```
 }
```
扩展格式
初始化语句;
while(条件判断语句){
```
 循环体语句;
```
```
 控制体/步长语句;
```
}
流程:
初始化语句执行一次
判断条件是否成立,成立,则执行循环体,再依次执行步长语句;
…
如果不成立,while循环语句结束!
**注意事项：一般来说，知道具体循环次数的通常使用for循环；不知道循环次数的通常用while循环。
while的死循环：当while后的表达式为true时，会出现死循环。
经典例题：
(1)用while循环求出水仙花数并统计个数

public class While1 {public static void main(String[] args) {int i=100;int count=0;while (i<1000){if(((i % 100 / 10) * (i % 100 / 10) * (i % 100 / 10) + (i % 10) * (i % 10) * (i % 10) + (i / 100) * (i / 100) * (i / 100)) == i){count++;System.out.println(i);}i++;}System.out.println(count);}
}

do-while循环

格式
初始化语句;
do{
```
 循环体语句;
```
```
 步长语句/控制体语句;
```
}while(条件表达式) ;
流程:

 初始化语句执行一次,对变量进行赋值

```
 执行循环体语句,
```
```
 执行步长语句(++或者--)
```

 判断while后的条件是否成立,成立,继续执行循环体语句...

```
 不成立,语句结束!
```
do-while循环和for循环以及while循环的最大的区别就是:循环体至少执行一次!

for循环嵌套

 for(初始化语句;条件表达式;步长语句){

     //内层循环是外层循环的循环体语句

     for(初始化语句;条件表达式;步长语句){

```
             循环体语句;
```
```
     }
```
```
 }
```

*将内层循环看成是外层循环的循环体语句;
经典例题：
打印99乘法表：

public class For3 {public static void main(String[] args) {int sum=1;for(int i=1;i<=9;i++){for (int j=1;j<=i;j++){sum=i*j;System.out.print(j+"*"+i+"="+sum+"\t");}System.out.println();}}
}

跳转控制语句：

break :中断,结束
continue : 继续(循环中使用,结束当前循环,立即进入下一次循环)
return :结束方法(和方法相关)

=====================================================================

#day2.

1.方法的定义

在Java中什么是方法呢?
将共性内容抽取出来,使用{}包裹起来,为{}起名字—方法 (一个独立的代码块{})
```
重点:
```
```
 如何定义一个方法
```

 第一种格式:有具体返回值(数据类型)的方法

权限修饰符 + 静态修饰符 + 具体的返回值类型 + 方法名(数据类型1 变量名1 ,数据类型2 变量名2 ,…){
```
           //完成的业务逻辑
```
```
           return 结果;
```
```
    }
```
```
  详细解释:
```
```
 权限修饰符 :public
```
```
 静态修饰符:static(带上)
```

 具体的返回值类型:数据类型 (目前学习过的基本类型:没有告诉什么类型,都是默认int)

 方法名: 符号 标识符的规则: 小驼峰命名法:

```
 一个单词:字母全部小写
```

   多个单词:第一个单词小写,从第二个单词开始:每个单词首字母大写

```
 形式参数列表:
```

         数据类型1(目前学习过的基本类型:没有告诉什么类型,都是默认int) + 参数名1(变量名) ,  数据类型2 参数名2..

 return :结束方法: 必须返回具体结果;

经典案例
写一个方法，判断一个整数是否是质数
概念：质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数

import java.util.Scanner;
public class Menth {public static void main(String[] args) {Scanner src=new Scanner(System.in);System.out.println("请输入整数的值");int n=src.nextInt();run(n);}public static void run(int n){int count=0;for (int i=2;i<=n;i++){if(n%i==0){count++;}}System.out.println(count);if(count>=2){System.out.println("它不是素数");} else {System.out.println("它是素数");}}}

2.java中方法的两种调用
(1)*Java中有具体返回值类型的方法的定义和调用

定义:
固定格式:

     public static 返回值类型 方法名(形式参数列表){

```
         业务....
```
```
         return 结果;
```
```
     }
```
```
  调用方法:
```

     1)单独调用:(没有输出)没有意义

     2)输出调用:输出:写死了,不利于值的进一步操作

```
     3)赋值调用(推荐)
```

(2) java中没有具体返回值类型的方法定义以及如何调用

```
 方法定义格式:
```

     权限修饰符+静态修饰符+返回值类型 +方法名(形参列表){

                  没有return 语句 ;

                  直接完成输出操作

```
     }
```

  Java语法规定:当一个方法没有具体返回值类型的时候,使用void 代替

  public static void  方法名(形式参数列表){

```
     //打印*形的 for循环
```
```
      for(int x = 0 ; x < 5 ; x ++){
```
```
        for(int y = 0 ; y < 5; y++){
```
```
            System.out.print("*") ;
```
```
        }
```
```
        System.out.println() ;
```
```
    }
```
```
  }
```

  没有具体返回值类型的方法调用:

```
     单独调用(推荐)
```

** 注意事项

定义方法的注意事项:
1)方法与方法是平级关系 ,不能再一个方法中定义另一个方法 (不能再方法中定义)
2)Java是强类型语言 (语法结构非常严谨) 弱类型语言:前端:javascript (定义方法:不需要携带数据类型)

     定义形式参数:必须携带数据类

3)调用方法的时候

     数据类型 变量名 = 方法名(实际参数列表) ;实际参数如果定义了,传递参数,不需要携带类型

4)目前我们定义的方法都是有方法体的 (有左大括号"{ 的地方不能有分号; 有分号;的地方不能有左大括号"{" )

     权限修饰符 + 静态修饰符 +返回值类型 +方法名(形式参数列表){

```
     }
```

3.方法的重载

Java中的方法里面有特点: 方法重载的概念
需求:
求数据之和(使用方法改进) int类型
分析: 这个需求没有明确告诉我们几个数据进行求和
定义两个数据之和的方法
定义三个数据之和的方法
定义四个数据之和的方法
按照上面的这种写法:测试没有问题
三个方法:都是属于 “求和功能”
方法名----遵循标识符的规则:“见名知意”,都是"求和的功能",方法名可以相同
Java提供一个技术:方法重载 (overLoad)
含义:

     多个方法的方法名相同,参数列表不同,与返回值无关 ---将这些方法称为"方法重载"  -------   面向对象部分:(继承) 方法重写(override)

                 参数列表不同有两种情况

                         1)参数个数不同 (参数类型一致)

                         2)参数类型不一致(参数个数一致)

```
      举例:
```

             public static float sum(float a,float b) {}

             public static float sum(int a,float b){}

             public static int  sum(int a,int b){}

             public static double sum(double a,double b,double c)

             public static int add(int a,float b)

             public static int add(float a ,int b)

4.方法的练习题
写一个方法，计算两点(x1, y1)和(x2, y2)之间的距离（键盘录入数据）

import java.util.Scanner;
public class Math01 {public static void main(String[] args) {Scanner src=new Scanner(System.in);System.out.print("请输入x1的值:");int x1=src.nextInt();System.out.print("请输入x1的值:");int y1=src.nextInt();System.out.println(")");System.out.println("请输入x2的值");int x2=src.nextInt();System.out.println("请输入y2的值");int y2=src.nextInt();double d=num(x1,y1,x2,y2);System.out.println(d);}public static double num(int x1 ,int y1,int x2,int y2){double d=Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));return d;}
}

=====================================================================

#day3
1.什么是数组?

数组是一个容器,能够存储同一种类型元素的容器!
数组如何定义呢?
格式:
```
     数据类型[] 变量名称 ;
```
```
     数据类型 变量名称[] ;
```
```
     举例:
```

             int[] arr ; 定义了一个int数组的arr变量  (推荐这个格式)

             int arr[] ; 定义一个int类型的arr数组

数组的如何初始化呢?
两种初始化:
第一种初始化: 动态初始化

     动态初始化:  给定数组的长度,元素由系统默认初始化!

```
                 格式:
```

                     数据类型[] 数组名称  = new 数据类型[长度] ; (推荐)

                     数据类型 数组名称[] = new 数据类型[长度] ;

```
      举例:
```
```
             int[] arr = new int[3] ;
```

             引用类型:一旦对象创建了,地址值永远固定,除非重新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} ;

 //错误的:数组初始化只能有一种:不能既动态初始化,又静态初始化

案例分析：
(1)给定一个数组，输出数组中的最大值和最小值(5个元素)
注意：此案例没有用方法实现，为两个不同的测试类

public class Array {public static void main(String[] args) {int[] arr={1,2,3,4,5};int max=resve(arr);System.out.println(max);}public static int resve(int[] arr){int max=arr[0];for (int i=0;i<arr.length;i++){if(max<arr[i]){max=arr[i];}}return max;}}
public class Array {public static void main(String[] args) {int[] arr={1,2,3,4,5};int min=resve(arr);System.out.println(min);}public static int resve(int[] arr){int min=arr[0];for (int i=0;i<arr.length;i++){if(min>arr[i]){min=arr[i];}}return min;}}

(2)给定一个数组，把这个数组中所有元素顺序进行颠倒。（静态初始化）

public class Array05 {public static void main(String[] args) {int arr[]={1,2,3,4,5};hu(arr);for (int x=0;x<arr.length;x++){System.out.println(arr[x]);}}public static void hu(int arr[]){for (int i = 0; i < arr.length/2; i++) {int temp=arr[i];arr[i]=arr[arr.length-1-i];arr[arr.length-1-i]=temp;}}
}

(3)查询元素第一次在数组中出现的索引,查询元素使用功能完成!

import java.util.Scanner;
public class Array03 {public static void main(String[] args) {Scanner src=new Scanner(System.in);System.out.println("请输入搜索的数:");int a=src.nextInt();int[] arr={10,55,30,24,17};int sou=sourch(arr,a);System.out.println(sou);
}
public static int sourch(int[]arr,int a){for (int i = 0; i < arr.length; i++) {if (a == arr[i]){return i;}}return -1;
}
}

关于常见的两个异常(程序出问题了):

         数组:---数组角标越界异常:

         ArrayInddexOutOfBoundsException :程序运行时出错---- 运行时期异

```
         出现错误的原因:
```

                 开发者在书写代码的时候导致,角标值超出了数组的长度

                 解决方案: 只要正常访问角标值就可以

        引用类型-----出现空指针异常

        NullPointerException: 程序运行时出错---运行时期异常

```
         出现的原因:
```

             某个对象(数组)已经为null了,堆内存中没有空间地址值了,开发者还试图访问这个对象(数组)中的元素,就会有问题

```
         解决方案:
```

                 针对对象:进行逻辑判断

                     如果对象不为null,再去访问;

=====================================================================

#day4
1.经典算法题
冒泡排序：

public class MaoPao {public static void main(String[] args) {int[] arr={43,65,3,6,76};arrays(arr);arrayk(arr);}public static void arrays(int[] arr){for (int i = 0; i < arr.length-1; i++){for (int j = 0; j < arr.length-1-i; j++){if(arr[j]>arr[j+1]){int temp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;}}}}public static void arrayk(int[] arr){System.out.print("[");for (int i = 0; i < arr.length; i++){if(arr[i]==arr[arr.length-1]){System.out.print(arr[i]+"]");}else {System.out.print(arr[i]+" ");}}}
}

2… 关于基本数据类型和引用数据类型(数组)作为形式参数的问题研究

基本数据类型作为形式参数传递有什么特点:
基本类型作为形式参数传递,形式参数的改变不会影响实际参数,实际参数是什么,它的值还是那个原来的数据!
引用数据类型作为形式参数传递有什么特点: (后期研究的肯定是引用类型)
引用类型(数组,类,接口) 作为形式参数传递,形式参数的改变会直接影响实际参数!
3…类与对象
类—Java中的最基本单元
描述现实世界事物的属性和行为的集合!
描述现实世界真是存在的事物:
分析:
学生事物
属性:姓名,年龄,身高,性别
行为: 学生主要学习
学生可以玩游戏(会玩高端:吃鸡游戏/steam:战地/…)
将上面的分析真实存在的事物-----变成Java代码(程序方式描述)
学生类 (统称)
将事物的属性-----成员变量(类中,方法外)
(name,age,high,gender)
将事物的行为-----成员方法(和我们之前学习的方法是一样的,去掉static)
public 有返回值类型方法名(形式参数列表){
return 结果;
}
public void 方法名(形式参数列表){
输出…
}
类和对象的关系
对象:应该是指定的某个类中具体的事物
学生事物
张三
李四
class Student{
//定义成员变量 (学生事物的属性)
//定义成员方法(学生事物的行为)
}
//测试类中
对象:描述具体事物
创建对象的格式:
类名对象名 = new 类名() ;
Student s = new Student() ;
//给学生赋值:姓名,年龄,身高,性别
对象名称.成员变量= 赋值;
//使用学生的行为:访问成员方法
对象名.方法名() ;
4.面向对象的特点
面向对象本质就是基于面向过程:

面向过程:代表语言就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类  ---- 完成对象 的创建以及录入的数据

需求:
将大象装进冰箱!

伪代码
面向过程:一步一步分析,一步一步完成

        测试类:Democlass 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 :名词提前法大象----大象类冰箱----冰箱类测试类:Democlass 大象类{public static void in(){System.out.println("大象进去...") ;}}class 冰箱类{public static void open(){System.out.println("打开冰箱门") ;}public static void close(){System.out.println("关闭冰箱门") ;}}测试类:Democlass Demo{public static void main(String[] args){//能够创建冰箱类对象冰箱类对象.open() ;//如果能够创建大象类对象大象类对象.in() ;冰箱类对象.close() ;}}

类与对象的代码实现：
(1)手机有品牌``,价格,颜色,内存等属性,手机可以打电话,发短信,打游戏等行为,请使用面向对象的方式描述手机并且进行测试

class Phone{String name;String color;int price;int memory;public void playPhone(){System.out.println("打电话");}public void study(String studyName){System.out.println("他正在学习"+studyName);}public void game(String gameName){System.out.println("他正在玩"+gameName+"游戏");}
}
public class Class01 {public static void main(String[] args) {Phone phone=new Phone();phone.name="华为" ;phone.color="蓝色";phone.price=2355;phone.memory=128;System.out.println("它的手机是:" + phone.name+",颜色是"+phone.color+",价格是:"+phone.price+"元"+",内存是："+phone.memory+"g");phone.playPhone();phone.study("java");phone.game("地下城");}
}

(2)定义一个计算器类，提供加键乘除的功能，并进行测试
注意：若要选择某种计算方法，可以在代码中加入键盘输入以及switch语句进行选择输出

import java.util.Scanner;
class Cacal{int num1;int num2;int num3;int num4;public void add(int num1,int num2){System.out.println("加法：");}public void jian(int num1,int num2){System.out.println("减法：");}public void chen(int num1,int num2){System.out.println("乘法：");}public void chu(int num1,int num2){System.out.println("除法：");}
}
public class Class03 {public static void main(String[] args) {Cacal cacal=new Cacal();Scanner src=new Scanner(System.in);System.out.println("请输入数字1:");int a=src.nextInt();System.out.println("请输入数字2:");int b=src.nextInt();cacal.num1=a;cacal.num2=b;int sum=cacal.num1+cacal.num2;cacal.add(a,b);System.out.print(cacal.num1+"+"+cacal.num2+"="+sum);System.out.println();int ji=cacal.num1-cacal.num2;cacal.jian(a,b);System.out.print(cacal.num1+"-"+cacal.num2+"="+ji);System.out.println();int ch=cacal.num1*cacal.num2;cacal.chen(a,b);System.out.print(cacal.num1+"*"+cacal.num2+"="+ch);System.out.println();int cu=cacal.num1/cacal.num2;cacal.chu(a,b);System.out.print(cacal.num1+"/"+cacal.num2+"="+cu);}
}

=====================================================================

#day5
1.经典面试题
.简述成员变量和局部变量？
（1）定义的位置不一样成员变量在类中，方法外；而局部变量在方法内部
（2）作用范围不一样
成员变量作用范围是整个类
成员变量的作用范围是方法体
（3）默认值不一样
成员变量有默认值
局部变量没有默认值
（4）内存的位置不一样
成员变量位于堆内存
局部变量位于栈内存
（5）生命周期不一样
成员变量随着对象创建而诞生，GC回收而消失；
局部变量随着方法进栈而诞生，出栈而消失
2.形式参数和实际参数的传递

形式参数如果是基本数据类型,形参的改变不影响实际参数,
引用类型:除过String类,作为形式参数传递.形参的改变直接影响实际参数
结论:
String类作为形参传递,效果和基本数据类型作为形式参数传递是一样的
形式参数如果是基本数据类型,形参的改变不影响实际参数,
形式参数如果是引用类型,传递的是一个类,-----形参的改变直接影响实际参数!
3.匿名对象类
匿名对象:顾名知意: 没有名字的对象
类名对象名 = new 类型() ; 有名字的对象
匿名对象的格式:
```
  new  类名() ;
```

  new 类名().成员方法名() ; 访问当前类中的成员方法

特点:

  1)匿名对象:使用完毕,会立即垃圾回收器回收,节省内存空间!

   应用场景:都是在移动端使用居多---Android :基于Java (大部分都是使用匿名对象,节省内存)

  2)开发中,匿名对象使用一次即可,不要使用多次! (使用完毕,就立即被回收)

  3)匿名对象可以作为参数传递

4.封装

Java提供一个关键字:private 封装
将一个类中的成员变量(属性)私有化,对外提供公共的访问方法,来保证类的安全性
目的:为了外界不能够直接访问
- ```
  private(私有)关键字:
```

  被private修饰的成员变量,成员方法只能在本类中访问,外界类不能访问

5.this关键字
this:代表当前这个类的对象的地址值引用
作用：1.区分成员变量和局部变量
2.代表当前对象
3.构造器与构造器之间的调用
6.如何定义一个标准的类
代码实现：
(1)定义一个长方形类，长和宽是它的两个属性，定义为成员变量，求长方形的面积和周长
（思路：周长和面积可以定位它的两个成员方法），提供测试类进行测试，长和宽使用键盘录入数据

class Rect1{private int longe;private int width;public void setLonge(int longe){this.longe=longe;}public int getLonge(){return longe;}public void setWidth(int width){this.width=width;}public int getWidth(){return width;}public int area1(int longe,int width){int area1=longe*width;return area1;}public int perimeter1(int longe,int width){int perimeter1=2*(longe+width);return perimeter1;}
}
public class Class12 {public static void main(String[] args) {Scanner scanner=new Scanner(System.in);System.out.println("请输入长方形的长：");int a=scanner.nextInt();System.out.println("请输入长方形的宽：");int b=scanner.nextInt();Rect1 rect1=new Rect1();rect1.setLonge(a);rect1.setWidth(b);rect1.area1(a,b);System.out.println("长方形的面积为："+rect1.area1(a,b));rect1.perimeter1(a,b);System.out.println("长方形的周长为："+rect1.perimeter1(a,b));}
}

(2)定义一个笔记本类，该类有颜色（char）和cpu型号（int）两个属性。
1) 无参和有参的两个构造方法；有参构造方法可以在创建对象的同时为每个属性赋值；
2) 输出笔记本信息的方法
3) 然后编写一个测试类，测试笔记本类的各个方法

class Computer{private char coclor;private int cpu;public void setCoclor(char coclor){this.coclor=coclor;}public char getCoclor(){return coclor;}public void setCpu(int cpu){this.cpu=cpu;}public int getCpu(){return cpu;}public void playGame(){System.out.println("可以玩游戏");}public void look(){System.out.println("可以看电视");}
}
public class Class10 {public static void main(String[] args) {Computer computer=new Computer();computer.setCoclor('蓝');computer.setCpu(1070);System.out.println("笔记本的颜色是："+computer.getCoclor()+"   笔记本的CPU是："+computer.getCpu());computer.look();computer.playGame();}
}

=====================================================================
总结
本周主要学习了java中流程控制语句，三种循环，方法，数组，构造方法，类，面向对象，封装以及如何创建一个标准的类，通过一周的学习，已经基本掌握各种循环思想，一维数组的应用以及数组和对象的内存图解，对面向对象思想有了简单的认识。

java学习第二周周记相关推荐

Java学习---第二周周报
第二周周报收获关于第一周知识的查漏补缺 JDK,JRE,JVM 分别是什么,彼此之间的关系是怎么样的? JDK为Java语言的软件开发工具包,是整个Java的核心:包含JRE和JVM JVM是Ja ...
Java学习第二周(2)--排序算法与二维数组
声明:由于学习环境为JDK1.8,所有有关Java的代码均在JDK1.8环境中测试通过,若环境发生变换,代码可能会发生错误. 本周的学习难度较上周有明显提升,今天所学习的排序算法有很多需要理解 ...
Java学习第二周总结
1.位运算符 1.1位运算符: 针对多个数据进行操作(使用"补码"计算结果)计算出来的结果是具体的数据值; 1)基本的位运算符:位与&: 有0,则0位或|: 有1,则1位异 ...
临摹中国慕课静态网页第二周周记（CSS3+JS）
临摹中国慕课静态网页第二周周记(CSS3+JS) 第二周这周主要是对细节,轮播图,下拉菜单等地完善和JS的学习学习内容 (1)CSS word-break 属性属性规定自动换行的处理方法. 语法 ...
201671010140. 2016-2017-2 《Java程序设计》java学习第一周
java学习第一周本周是新学期的开端,也是新的学习进程的开端,第一次接触java这门课程,首先书本的厚度就给我一种无形的压力,这注定了,这门课程不会是轻松的,同时一种全新的学习方 ...
深入理解吴恩达老师深度学习课程（01神经网络和深度学习第二周）
深入理解吴恩达深度学习(01神经网络和深度学习第二周) 1引言 2.1 二分类(Binary Classification) 2.1.1 符号定义(视频给出的) 2.2 逻辑回归(Logistic ...
Python学习第二周总结
Python学习第二周总结第二周主要学了python中几种常见的数据结构,分别是列表.元组.字符串.集合.字典重点就是怎么创建和使用这些数据结构,操作方法更是一定要掌握的. 一.列表 1.1 定 ...
invader的java学习第二天基础篇
invader的java学习第二天基础篇一.深入了解第一个Hello World程序 public class Hello World{ public static void main(String ...
吴恩达深度学习第二周--logistic回归作业1
吴恩达深度学习第二周–logistic回归作业1 本系列为吴恩达老师深度学习作业的总结,其中参考了很多优秀的文章,本文为了方便日后的复习与巩固,更为详细的作业讲解参考目录吴恩达深度学习第二周--l ...

java学习第二周周记

java学习第二周周记相关推荐

最新文章

热门文章