JAVA第二周总结类与对象

68 阅读 0 评论 45 点赞

我是靠谱客的博主感动猫咪，这篇文章主要介绍JAVA第二周总结类与对象，现在分享给大家，希望可以做个参考。

1.循环之switch语句.

switch格式:

switch(表达式或者某个变量的值){

case 值1:

语句1;

break;

case 值2:

语句2;

break;

default:

语句;

break;

}

执行流程: 首先switch接收结果

1)接收的结果和case后面的值1进行对比,成立,执行语句 1,break 结束语句;

2)值1和switch接收的结果不匹配,和值2进行比较,成立,执行语句2, break,结束语句;

3)... 如果上面case都不匹配,执行default语句,语句n,break ,结束语句;

注意事项:

1)关于switch中的case语句后面只能是常量,不能是变量 (体现Java是一种强类型语言) ----前端的javascript:它里面的swtich的case是可以是变量,可以是个常量;

2)在书写switch语句的标准结构,不忘了break,如果语句中忘了书写break,会出现一个现象:case穿透! 在有的需求里面利用 case穿透来完成一些需求;

3)关于switch语句的结束条件 a)要么遇见break结束 b)程序默认执行到末尾;

4)关于default语句可以在switch语句中的任何位置,不影响语句的执行流程; 不管在任何位置,只要case语句都不匹配,执行default; 如果default语句的末尾,break可以省略;

2.跳转控制语句.

break :在 looper循环或者switch中用 (中断,结束...)

continue:继续 (循环中用,结束当期循环之后,立即进入下一次循环了)

return : 结束方法用的 (很少单独使用)

结合有具体返回值类型的方法的使用(有具体返回类型,必须有结果),返回必须带回一个结果.

3.进制转换法.

十进制转化为任意进制:

使用当前十进制数据本身除基,求余,直到除到商为0为止,余数反转.

任意进制转化为十进制:

位权展开法:系数*基数的权次幂相加;

4.for循环与while循环的区别?

共同点:都是能够体现循环思想,解决代码冗余问题

不同点: 1)格式不同 ;

2)使用场景不同 for循环(普通for循环),明确循环次数优先采用for (实际开发中for使用很频繁:遍历数组,获取数组的元素) ;

while循环: 不明确循环次数使用while循环

3)从内存角度是否节省内存 for循环的这种格式,比较节省内存资源,当for循环结束,里面的变量被释放了, 这个变量作用域就在 for(初始化语句;条件表达式;控制体语句){ 循环体语句; } while循环,相对for循环,比较消耗内存,当while循环结束,依然能够访问变量.

5.switch语句后面的表达式可以是什么数据类型?

可以跟的基本数据类型 byte,short ,int ,char;

jdk5以后,可以枚举类型;

jdk7以后,可以String类型;

6.while死循环.

死循环:利用死循环完成一些需求,死循环中肯定需要使用逻辑判断; 当达到某种条件的时候,应该结束死循环;

典型案例:猜数字游戏

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.util.Scanner;
public class Test {   
       public static void main(String[] args) {   
       int a =0;       
       int count = guess(a);     
       System.out.println(count+"次猜中了!!!");   
           } 

  
      public  static int guess(int a){ 
    
          int b =(int)( Math.random()*100+1);     
          int count=0;     
          System.out.println("请输入数据a:");   
          while(true){        
          count++;         
          Scanner sc = new Scanner(System.in);      
          int  c = sc.nextInt();     
          if (b>c){        
                  System.out.println("不好意思,你猜小了!!");     
           }else if(b<c){        
                 System.out.println("不好意思,你猜大了!!");    
           }else if(b == c){      
                 System.out.println("恭喜你,猜对了!!!");     
                  break;      
           }else{        
                 System.out.println("输入数据不合法!!");    
           }    
    }    
                 return count;  
  } 
}

7.java中定义方法的格式:有具体返回值类型的方法的定义以及调用.

定义: public static 返回值类型方法名(形参数据类型形参,形参数据类型形参...){

业务逻辑;

return..;

}

调用: 返回值类型变量 = 方法名(实参,实参....);

8.没有返回值类型的方法的定义以及调用.

定义: public static void 方法名(形参的数据类型形参,形参的数据类型形参...){

业务逻辑;

输出结果;

}

调用格式:

单独调用

方法名(实参,实参.....);

实例:

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数据n:");
        int  n = sc.nextInt();
        cheng(n);
    }

    public static void  cheng(int a){
          for (int i = 1;i<=a;i++){
              for(int j =1;j<=i;j++){
                  System.out.print(i+"*"+j+"="+(i*j)+"t");

              }
              System.out.println();
          }
    }


}

9.JVM内存分配有那些,有什么作用?

栈内存:存储局部变量用的这个内存区域.

堆内存: new出来的对象存储在这个区域.

方法区: 字节码文件区域----->方法调用过程需要加载类;

static区域---------->main方法就是被static修饰的;

常量池------->常量的都是在常量池.

寄存器

本地方法区

10.什么是方法重载?

为了某个功能扩展性,多个方法方法名可以相同(完全相同),参数列表不同,与返回值无关;

参数列表不同: 参数的类型不同,参数个数不同,参数的顺序不同.

11.什么是数组,数组的定义格式有那些?

定义:数组是一种容器,容器只能存储同一种类型的元素.

动态初始化:自己定义数组的长度,数组的元素有系统(jvm)默认分配;

格式: 数据类型[] 数组名称 = new 数据类型[数组长度] ; 推荐第一种

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

int[] arr = new int[80] ;

int arr[] = new int[80];

静态初始化:直接我们自己给定的了元素内容,数组的长度由系统默认分配 .

数据类型[] 数组对象名 = {元素1,元素2,元素3.....} ; 推荐的写法

数据类型数组对象名[] = {元素1,元素2,元素3.....} ;

int[] arr = {1,2,3} ;

int arr[] = {1,2,3} ;

在数组中有一个特有的属性:length

数组名称.length:获取数组长度

数组中的最大索引值: 数组名称.length-1

12.定义一个数组,对其进行遍历,逆序.

复制代码

import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) {

Scanner sc = new Scanner(System.in);
        System.out.println("请输入数据a:");
        int a = sc.nextInt();
        System.out.println("请输入数据b:");
        int b = sc.nextInt();
        System.out.println("请输入数据c:");
        int c = sc.nextInt();
        System.out.println("请输入数据d:");
        int d = sc.nextInt();
        System.out.println("请输入数据e:");
        int e = sc.nextInt();

int[] arr={a,b,c,d,e};
        System.out.println("遍历数组为:");
        bianLi(arr);
        System.out.println("逆序数组为:");
        ni(arr);
    }
    public static void bianLi(int[] arr){
        System.out.print("[");
        for(int i = 0;i < arr.length;i++){
            if(i== arr.length-1){
                System.out.println(arr[i]+"]");
            }else{
                System.out.print(arr[i]+", ");
            }
        }
    }
    public static void ni(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;
        }
        bianLi(arr);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import java.util.Scanner;


public class Test1 {
    public static void main(String[] args) {


        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数据a:");
        int a = sc.nextInt();
        System.out.println("请输入数据b:");
        int b = sc.nextInt();
        System.out.println("请输入数据c:");
        int c = sc.nextInt();
        System.out.println("请输入数据d:");
        int d = sc.nextInt();
        System.out.println("请输入数据e:");
        int e = sc.nextInt();


        int[] arr={a,b,c,d,e};
        System.out.println("遍历数组为:");
        bianLi(arr);
        System.out.println("逆序数组为:");
        ni(arr);
    }
    public static void bianLi(int[] arr){
        System.out.print("[");
        for(int i = 0;i < arr.length;i++){
            if(i== arr.length-1){
                System.out.println(arr[i]+"]");
            }else{
                System.out.print(arr[i]+", ");
            }
        }
    }
    public static void ni(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;
        }
        bianLi(arr);
    }
}

13.自定义一个数组,对其进行冒泡排序.

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class Test1 {
    public static void main(String[] args) {
      int[] arr= {12,456,75,25,64,258,456};
        System.out.println("遍历数组:");
        bianLi(arr);
        System.out.println("对数组排序后为:");
        maoPao(arr);
    }
    public static void bianLi(int[] arr){
        System.out.print("[");
        for(int i = 0;i < arr.length;i++){
            if(i== arr.length-1){
                System.out.println(arr[i]+"]");
            }else{
                System.out.print(arr[i]+", ");
            }
        }
    }
    public static void maoPao(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;
              }
           }
       }
       bianLi(arr);
    }
}

14.面试题 in[] arr = new int[2];完成了那些事情?

首先在栈内存中给int[] arr开辟了一个空间;

其次new int[2]在堆内存中申请了一个空间,

系统堆数组的内容进行初始化,并且数组中元素默认为0;

系统默认初始化完毕,产生了一个堆内存空间地址值;

int[2]将地址值赋值给了arr,而arr指向内存空间地址;

15.形式参数分别为基本类型和引用类型(数组的情况)的不同情况？

形式参数为基本类型: 当形参传递时不会影响实际参数.

形式参数为引用类型:当形参传递时会改变实际参数. (String当做基本类型对待)

类与对象

1.面向对象的思想特点? 三大特征?

思想特点:

更符合生活中的思想行为习惯

让复杂的事情简单化

让我们从执行者变成指挥者

三大特征:

封装继承多态

2.局部变量和成员变量的区别?

位置不同:局部变量存在于方法块或者参数列表中,

而成员变量在方法外的类中.

周期不同:局部变量的周期随着代码块的运行而产生, 结束运行则局部变量消失.

成员变量是随着创建对象而产生,跟随对象的消失而消失.

初始值不一样:局部变量没有默认初始值.

而成员变量具有默认初始值.

3.创建一个类对象的格式以及如何访问成员变量,访问成员方法

创建对象格式:

类名变量名 = new 类名();

访问成员变量: 变量名.成员变量 = " ";

访问成员方法: 变量名.成员方法();

实例:

学生事物属性：姓名，年龄，性别，发型

行为：吃饭，抽烟，打游戏，学习Java

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//学生类
public class Student {
       String name;
       int age;
       String sex ;
       String  hairStyle;

       public void eat(String e){
           System.out.println("正在吃"+e);
       }
       public void smoke(String s){
           System.out.println("正在抽"+s);

       }
       public void play(String p){
           System.out.println("正在打"+p);
       }
       public void study(){
           System.out.println("正在学习Java");
       }
}
//学生测试类
public class StudentTest {
    public static void main(String[] args) {
        Student s = new Student();
        s.name = "张三";
        s.age = 23;
        s.sex = "男";
        s.hairStyle = "锡纸烫";
        System.out.println("我的名字是"+s.name+",我的年龄是"+s.age+
                ",我是"+s.sex+"性,我的发型是"+s.hairStyle);

        s.eat("午饭");
        s.smoke("中华");
        s.study();
        s.play("和平精英");
    }
}

键盘录入长方形的长和宽，长方形事物的行为计算长方形的周长和面积;

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//长方形类
public class Rectangle {

    public void circumference(double l,double w){
        double c = (l+w)*2;
        System.out.println("长方形的周长为"+c);
    }
    public void area(double l,double w){
        double a = l*w;
        System.out.println("长方形的周长为"+a);
    }
}
//长方形测试类
import java.util.Scanner;

public class RectangleTest {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("录入长方形的长l:");
        double l = s.nextDouble();
        System.out.println("录入长方形的宽w:");
        double w = s.nextDouble();

        Rectangle  rectangle = new Rectangle();
        rectangle.area(l,w);
        rectangle.circumference(l,w);

    }
}

3.private关键字的特点?
1)被private修饰的成员变量以及成员方法只能在本类中访问;
2)可以修饰成员变量也可以成员方法,就是为了外界不能直接访问;
3)被private修饰的成员变量/成员方法可以间接的通过公共(setXXX()/getXXX()公共方法)的方法访问;

private实例:

复制代码

//学生类
public class Student {
       private String name;
       private int age;
       private String sex ;
       private String  hairStyle;

public void setName(String n) {
        name = n;
    }
    public String getName(){
        return name;
    }

public void setAge(int a){
        age = a;
    }
    public int getAge(){
        return age;
    }
    public void setSex(String s){
        sex = s;
    }
    public  String getSex(){
        return sex;
    }
    public void setHairStyle(String h){
        hairStyle = h;
    }
    public  String getHairStyle(){
        return  hairStyle;
    }
    public void show(){
        System.out.println("我的姓名是"+name+",我是"+sex+"性,我的年纪是"+age+"岁,我的发型是"+hairStyle);
    }
    public void eat(String e){
           System.out.println("正在吃"+e);
       }
       public void smoke(String s){
           System.out.println("正在抽"+s);

}
       public void play(String p){
           System.out.println("正在打"+p);
       }
       public void study(){
           System.out.println("正在学习Java");
       }
}
//学生测试类
public class StudentTest {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("王麻子");
        s.setSex("男");
        s.setAge(32);
        s.setHairStyle("锡纸烫");
        s.show();
        s.eat("午饭");
        s.smoke("中华");
        s.study();
        s.play("和平精英");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
//学生类
public class Student {
       private String name;
       private int age;
       private String sex ;
       private String  hairStyle;

    public void setName(String n) {
        name = n;
    }
    public String getName(){
        return name;
    }

    public void setAge(int a){
        age = a;
    }
    public int getAge(){
        return age;
    }
    public void setSex(String s){
        sex = s;
    }
    public  String getSex(){
        return sex;
    }
    public void setHairStyle(String h){
        hairStyle = h;
    }
    public  String getHairStyle(){
        return  hairStyle;
    }
    public void show(){
        System.out.println("我的姓名是"+name+",我是"+sex+"性,我的年纪是"+age+"岁,我的发型是"+hairStyle);
    }
    public void eat(String e){
           System.out.println("正在吃"+e);
       }
       public void smoke(String s){
           System.out.println("正在抽"+s);

       }
       public void play(String p){
           System.out.println("正在打"+p);
       }
       public void study(){
           System.out.println("正在学习Java");
       }
}
//学生测试类
public class StudentTest {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("王麻子");
        s.setSex("男");
        s.setAge(32);
        s.setHairStyle("锡纸烫");
        s.show();
        s.eat("午饭");
        s.smoke("中华");
        s.study();
        s.play("和平精英");
    }
}