第二周Java学习周总结

最新推荐文章于 2024-06-12 22:18:06 发布

zhangjinyan1

最新推荐文章于 2024-06-12 22:18:06 发布

阅读量131

点赞数

文章标签：学习

本文链接：https://blog.csdn.net/zhangjinyan1/article/details/127694646

版权

10.31晨写

1.位运算中位异或的特点？
位异或：一个数据被另一个数据位异或两次，就是它本身！
位异或^：相同为0，不同为1

2.流程控制语句if...else...它的执行流程
格式：
   if（表达式）{
       语句 1；
   }else{
       语句2；
   }

3.Java中的数据类型划分有哪些？
基本数据类型，引用数据类型：
   基本数据类型：四类八种
   整数类型：bety,short,int,long(默认 int)
   浮点类型:float,doubt（默认）
   字符类型：char
   布尔类型:boolean
   引用类型:数组，类，接口

4.有关逻辑与单&和逻辑与&&的区别？
单&逻辑语句左边是false后仍然会运行完整个语句，双&&前面是false后，右边不运行，直接运行下一个语句。
5.位运算符<< 和>>的特点？
   <<：将数据进行左移，右边不够的补0，将左移最多余的位数丢弃掉
   结论：将<<符号左边的数据乘以2的移动次幂
   >>:将数据进行右移，如果最高符号位是1，则左边补1；最高符号位是0，左边补0，右移后
多余的位数丢弃掉

11.1晨写

1.if...else 和三元运算符的区别
共同点：两种情况都可以进行批判，成立对应的内容，不成立，执行不成立的内容
区别：三元运算符是操作符号，属于运算符，一般都是具体的数据值，而它里面不能使用输出语句；
它相对if...else...来说，范围很小；
而if...else...是流程控制语句，它不仅仅是操作数据值，而且可以打印内容；范围大。
if语句可以的实现的三元运算符不一定可以，三元运算符可以的实现的，if语句一定可以

2.for循环和while循环的区别？
1）格式不同
   for(初始化语句；条件表达式；控制体语句){
       循环体语句；
   }
   初始化语句；
   while（条件表达式）{
       循环体语句；
       控制体语句；
   }
2）是否明确循环次数
若明确循环次数，使用for循环
不明确循环次数，使用while循环
3）是否节省内存空间
for循环优于while循环的这种格式；因为for结束，里面的变量及时从内存中释放，节省内存资源消耗
3.什么是水仙花数for循环获得所有的水仙花数
百位十位个位的数字的立方根等于这个数本身

class Fortest{
    public static void main(String[]args){
    for(int x = 100 ;x<=999; 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);
        }
    }
    }

}

4.switch语句后面的变量可以是什么数据类型？
byte,short,int,char
jdk5以后可以是枚举 enum枚举名{}
jdk7以后可以是String

传统自定义常量
public static final 数据类型变量名 = 值；

5.switch语句中有哪些注意事项？
switch语句
   case语句后只能是常量
   default语句可以在语句中的任何位置000000000
       如果在语句的末尾，break可以省略；
       但是在语句中，break不要省略（考点）
   switch语句的结束条件：
       1）遇见break语句结束；
       2)程序默认执行到末尾

11.2晨写

1.break中断当前循环或语句，continue直接进入下一次循环，return返回值
2.返回实数用int 返回小数用double 返回不知道的类型用void
3. public static void 方法名(参数类型1 参数名，参数类型2，变量2 ...)
4.使用同样的方法名，参数类型不同，参数个数不同，参数顺序吧不同；（与返回值无关）的方法

11.3晨写

1.什么是数组
数组是一个容器，可以存储多个元素，这多个元素必须是同一种数据类型
数组可以存储及基本数据类型的元素，也可以存储引用数据类型的元素！
缺点：长度是固定的，不适合这种长度一直变化的需求！

2.数组的定义格式以及初始化格式
数组的定义格式：
   数据类型[] 数组名称；
   数据类型数组名称[]；
初始化格式：创建对象的格式---动态初始化、静态初始化；
动态初始化：
   数据类型[] 数组名称 = new 数据类型[数组长度]；
   数据类型数组名称[] = new 数据类型[数组长度]；
静态初始化：
   数据类型[] 数组名称 = new 数据类型[]（元素1，元素2，元素3....）；
   数据类型数组名称[] = new 数据类型[]（元素1，元素2，元素3....）；
静态初始化的简写格式：
   数据类型[] 数组名称 = （元素1，元素2，元素3....）；

3.jvm内存分配有哪些？分别作用
栈内存：存储局部变量（在方法定义中或者方法声明上），局部变量跟方法有关的；方法进栈，
方法调用完毕，里面局部变量随着调用结束而消失
堆内存：
new出来的东西（引用数据类型）存储在堆中，而且它是随着对象的创建完毕，产生堆内存
空间地址值；
方法区：
里面很多的区域：class字节码文件区域--存储字节码文件--jvm需要加载这个类，解析这个类所有的方法以及变量
（这个过程--“反射技术”）
   static区域：--静态区域--存储跟static相关的一些方法以及变量等等
   constant pooll：常量池里面存储常量相关的
本地方法区：和系统相关的--创建系统资源完成系统相关的操作
寄存器：和系统cpu有关系：电脑的核数--核数越大，高并发场景下，运行效率越高；

4.数组的遍历--代码体现

public static void printArrry(int[] arr){
    system.out.print("[");
    for(int  x = 0 ; x < arr.length; x++){
        if(x==arr.length - 1){
            system.out.println(arr[x]+"]");    
        }else{
            system.out.print(arr[x]+",");
        }
    }
}

5.请描述冒泡排序思想以及核心代码体现
两两比较，如果前面的元素比后面的大，将前面的元素往后放（较大的往后走），第一次比较完毕，最大值就出现在
最大索引处；依次这样比较，就可以得到一个排好序的数组！

public static void bubbleSort(intp[] arr){
    for(int x=0; x<arr.length-1;x++){
        for(int y =0 ;y<arr.length-1;y++){
            if(arrr[y]>arr[y+1]){
                int temp = arr[y];
                arr[y] = arr[y+1];
                arr[y+1] = temp;
}
}
}

}

11.4晨写

1.面向对象的思想特点？
1)更符合现实生活中的思想行为习惯
2)让复杂的事情简单化
3)角色发生了改变:从执行者(面向过程)--->变成指挥者(面向对象)

2.面向对象的三大特征
封装继承多态

3.形式参数是基本数据类型和引用类型的区别？
1）形式参数如果是基本类型，形式参数改变不影响实际参数（包括特殊的应用java,lang
.String）
2）形式参数如果是引用数据类型，形式参数的改变直接影响实际参数的值

4.什么是类？如何在Java中描述具体事物？
类：描述事物的一组属性和行为的集合类和现实世界事物是一一对应的关系

5.成员变量和局部变量的区别？
1）在类中的位置不同
   成员变量类中方法外
   局部变量方法内或者方法声明上
2）在内存中的位置不同
   成员变量堆内存
   局部变量栈内存
3）生命周期不同
   成员变量随着对象的存在而存在，随着对象的消失而消失
   局部变量随着方法的调用而存在，随着方法的调用完毕而消失
4）初始化值不同
   成员变量有默认的初始化值
   局部变量没有默认的初始化值，必须先定义，赋值，才能使用。

面试题：

1.if...else...和三元运算符的区别?

        共同点:
                 都是针对两种情况进行判断,都有表达式;
       不同点:
           if...else...流程控制语句,范围很大,不仅仅可以操作数据值,还可以操作输出语句去完成逻辑判断;而三元运算符仅仅是运算符,操作两个具体的数据值;
       三元运算符能实现的一定能够使用if...else...流程语句 if....else....流程语句实现的,不一定能够使用三元!(流程控制语句操作 System.out.println())

2.switch语句后面的这个变量名可以是什么样的数据类型呢?

        本身能够跟的基本数据类型:byte,short,char,int
       Jdk5以后可以是枚举(引用类型) enum
       JDK7以后可以跟String类型

3.for和while循环有什么区别?

        1.从用法格式上看,格式不同,while循环的这个格式,不要忽略了控制体语句;
           for(初始化语句;条件表达式;控制体语句){
               循环体语句;
           }
           初始化语句;
           while(条件表达式){
               循环体语句;
               控制体语句;
           }
2.是否明确循环次数(开发中,优先使用for)
           如果需求明确了循环次数,优先使用for循环,工程上的for循环使用最多的!
           (最频繁的)
           如果不明确循环次数,使用while循环举例: 猜数字游戏(1-100的数据)
3.从内存角度考虑,for循环更优一些,比较节省内存空间
           从for循环本身的格式上来说,for循环结束,里面的局部变量(方法定义中的变量)就被及时的释放空间!
           while循环格式,结束之后,依然能够去访问那个变量,(比较消耗内存空间),所以相对来说whle循环没有for循环好

跳转控制语句：

break;continue;return

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

        System.out.println("程序开始了...");
        for(int x = 1 ; x <=10 ; x++){
            if(x == 3){
                System.out.println("条件成立了");
              //  break ;
               // continue;
                //return很少单独用,在有返回值的方法中用的(推荐)
                return;//结束方法的
            }
            System.out.println(x);
        }

        System.out.println("程序结束了");
    }
}

当语句是break，输出1，2和三个输出语句，当语句是continue时，输出1.2.4.5.6.7.8.9和10,还有三个输出语句，当语句是return，输出1.2和程序开始了，条件成立了。

方法重载：

java提供overload方法重载：多个方法的方法名可以相同,参数列表不同,与返回值无关! 参数列表不同:可以有下面几种：1.参数类型不同2.参数个数不同3.考虑参数的先后顺序不同

public class FunctionDemo4 {
    public static void main(String[] args) {
        //调用
        //为了方便,直接输出调用
        System.out.println(sum(10,20))
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
    }
    //两个数据求和的方法
    public static int sum(int a,int b){
        return  a+b ;
    }
    //三个数据求和
    //public static int sum2(int a,int b ,int c){
    public static int sum(int a,int b ,int c){
        return  a+ b+ +c ;
    }
    //四个数据求和
    //public static int sum3(int a,int b,int c,int d){
    public static int sum(int a,int b,int c,int d){
        return  a+b +c+d ;
    }


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

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

    public static double sum(double a,double b){
        return  a+b;
    }

    public static double SUM(double a,double b){//方法名不同
        return  a+b;
    }
}

冒泡排序：

两两比较,将较大的值往后放,第一次比较完毕,最大值就出现在最大索引处依次这样比较,可以得到一个排好序的数组;

bubbleSort(arr);
        //在调用遍历功能,展示数据
        printArray(arr);

    }
    /*
    * 定义一个冒泡排序的方法:
    *   两个明确
    *       明确返回值类型: 没有具体返回值 --直接元素里面互换  void
    *       明确参数类型  以及参数个数
    *               指定数组,1个
    * */
    public static void bubbleSort(int[] arr){
        for(int x = 0 ; x < arr.length-1;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;
                }
            }
        }
    }

    /**
     * 遍历数组的方法
     * @param arr 对已知的数组遍历
     */
    public static void printArray(int[] arr){
        System.out.print("[");
        //遍历数组
        for(int x = 0 ; x < arr.length ; x++){
            //判断:如果是最大索引值,取到最后一个元素
            if(x== arr.length-1){
                System.out.println(arr[x]+"]");
            }else{
                //中间的元素
                System.out.print(arr[x]+", ");
            }
        }
    }
}

形式参数：

形式参数如果是基本数据类型,形式参数的改变不影响实际参数!后面特殊的引用数据类型:String,作为形式参数和基本类型数效果一致!

局部变量的生命周期:(方法定义中,或者方法声明上):局部变量随着方法调用而存在,随着方法调用结束而消失

public class ArrayTest {
    public static void main(String[] args) {
        //下面代码,写成结果
        int a = 10 ;
        int b = 20 ;
        System.out.println("a:"+a) ;
        System.out.println("b:"+b) ;
        change(a,b) ;
        System.out.println("a:"+a) ;//10
        System.out.println("b:"+b) ;//20
        System.out.println("-----------------------------------");
        //String特殊引用类型,它作为形式参数和基本类型一致,形式参数的改变不影响实际参数
        String s = "helloworld" ;//String类:常用类中 是重点  (字符串是一个常量! String str ="abc";)
        System.out.println(s);//"helloworld"
        change(s);
        System.out.println(s);
    }
    public static void change(String s){//形式参数
        s += "javaEE" ;
    }
    public static void change(int a,int b){//基本类型作为形式参数 10,20
        a = b ;// a= 20
        b = a+b; //b = 20 + 20 =40
    }
}

引用类型作为形式参数,形式参数的改变是直接影响实际参数的,因为引用数据类型(数组,类,接口),是一种空间地址值进行传递,而基本数据类型只是数据值进行传递(随着方法调用存在,调用结束而消失)而引用类型---需要new--->需要在堆内存中开辟空间,对象使用完了,不会立即被回收,需要等待gc垃圾回收器空闲时刻自己回收!对象一旦被创建,永远指向那个地址值,除非重新new对象

public class ArrayTest2 {
    public static void main(String[] args) {
        //创建一个数组,静态初始化
        int[] arr = {1,2,3,4,5} ;
        System.out.println(arr[1]);//2
        change(arr) ;//----{1,4,3,8,5}
        System.out.println(arr[1]); //4
    }
    public static void change(int[] arr){//引用数据类型数组作为参数传递---空间地址值
        //遍历了数组
        for(int x= 0  ; x < arr.length ;x++){
            //获取到元素
            if(arr[x] %2==0){
                arr[x]*=2 ;
            }
        }
    }
}

匿名对象：

没有名字的对象！

有名字的对象---描述具体事物 ---创建对象格式类名对象名 = new 类名() ;

匿名对象格式:

new 类名();

特点:

1.可以作为"参数传递"

2.实际用的过程,匿名对象不要多次,一般使用一次即可,使用完毕立即被回收!在android中匿名对象使用居多 (移动端内存小,节省内存)

//定义一个人类
class Person{
    //人都需要工作
    public void work(){
        System.out.println("爱生活,爱Java,爱高圆圆");
    }
}
//定义一个PersonDemo
class PersonDemo{
    //成员方法
    public void function(Person p){//形式参数引用类型,调用这个方法的时候,需要创建Person类对象
        p.work();
    }
}


//测试类
public class NoNameDemo {
    public static void main(String[] args) {
        //使用有名字的对象访问:
        //访问PersonDemo类中 function()方法
        PersonDemo pd = new PersonDemo() ; //创建PersonDemo类对象
        //创建Person类对象
        Person p = new Person() ;
        pd.function(p);//创建Person类对象进行实际参数传递
        System.out.println("------------------------------------------------------");
        //匿名对象的格式 :new 类名();  --可以作为参数传递
        //访问PersonDemo类中 function()方法
        PersonDemo pd2 = new PersonDemo() ;
        pd2.function(new Person());

        System.out.println("------------------------------------------------------");
        //链式编程 (实际开发中:不推荐这种,自己去使用可以用这种格式)
        //访问PersonDemo类中 function()方法
        new PersonDemo().function(new Person());
    }
}

私有化类的调用

public class information {
    private String name;

    public void setName(String n){
        name = n ;
    }
}
public class phonetest {
    public static void main(String[] args) {

        information  information = new information() ;

        information.setName("小米");
      
            System.out.println("手机的品牌是:"+ information.getName());
        }
    }