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);
    }
}

3. do-while循环

• 格式
• 初始化语句;
• do{

•  循环体语句;
  

•  步长语句/控制体语句;
  

• }while(条件表达式) ;
• 流程:

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

•  执行循环体语句,
  

•  执行步长语句(++或者--)
  

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

•  不成立,语句结束!
  

• do-while循环和for循环以及while循环的最大的区别就是:循环体至少执行一次!

5. 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类  ---- 完成对象 的创建以及录入的数据

需求:
将大象装进冰箱!

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

        测试类: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() ;
            }

       }

类与对象的代码实现：
(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中流程控制语句，三种循环，方法，数组，构造方法，类，面向对象，封装以及如何创建一个标准的类，通过一周的学习，已经基本掌握各种循环思想，一维数组的应用以及数组和对象的内存图解，对面向对象思想有了简单的认识。