Javase 总结 week02

已于 2022-08-06 11:52:54 修改
阅读量124 收藏
点赞数 2
分类专栏： 笔记 文章标签： java
于 2022-08-06 11:50:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51429113/article/details/126183789
版权
本文详细介绍了Java编程中的流程控制语句，包括switch、for、while、do-while循环以及跳转语句的执行流程和应用场景。同时，讲解了方法的定义、调用、重载以及注意事项，并举例说明了如何求三个数中的最大值。此外，还探讨了数组的概念、操作和遍历，以及数组的逆序操作。最后，简述了面向对象的三大特征，并通过学生和手机类的例子展示了封装的概念和应用。
摘要由CSDN通过智能技术生成

流程控制语句 

switch 

格式:

    switch(表达式) {

        case 常量1:

        语句体1;

        break;

       case 常量2:

       语句体2;

       break;

       ......

       case 常量n:

      语句体n;

      break;

     default:

     语句体n+1;

     }

判断月份
import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入月份:");
        int a = sc.nextInt();
        switch (a) {
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9: 
            case 10:
            case 11:
                System.out.println("秋季");
                break;

            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            default:
                System.out.println("请输入合法数据!");
                break;
        }
    }
}

switch语句   执行流程:先匹配case里的内容  匹配不到 直接执行default

要注意加break,防止case穿透.

1.循环结构语句

for循环

格式:

  for(初始化语句; 逻辑表达式; 步进表达式) {

       循环语句体;

       }

执行流程:

  1. 执行初始化语句
  2. 执行逻辑表达式，如果返回false，直接结束for循环如果返回true，执行循环语句体循环语句体
  3. 执行完毕后，执行步进表达式
  4. 重复步骤(2) 

 示例:

水仙花数

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



nn乘法表


import java.util.Scanner;

public class nnTable {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入n:");
        int n = sc.nextInt();
        for(int i = 1;i<=n;i++){
            for (int j = 1;j<=i;j++) {
                System.out.print(j + "*" + i+ "=" + (i * j) + "\t" );
            }
            System.out.println();
        }
    }
}

while循环

格式:

        while(逻辑表达式) {

        循环语句体;

        步进表达式;

     }

执行流程：

  1. 执行初始化变量
  2. 执行逻辑表达式，如果为false，直接结束while循环,如果为true，执行循环语句体
  3. 执行步进表达式
  4. 回到步骤2.

 示例:

1-100 的奇数和
 public class sum {
    public static void main(String[] args) {
        int i = 1;
        int sum = 0;
        while(i<=100){
            if (i % 2==0) {
                sum=sum+i;
            }
            i++;
            }
        System.out.println(sum);
        }
    }

do - while

格式:

      初始化变量;

      do {

              循环语句体;

              步进表达式;

              } while(逻辑表达式);

执行流程：

  1. 执行初始化变量
  2. 执行循环语句体
  3. 执行步进表达式
  4. 执行逻辑表达式，如果返回false，整个循环结束
  5. 如果返回true，回到步骤2.

开发中常用for循环,不满足也需要执行一次的时候用do - while

死循环:  一直执行下去

               while(true){                                       for(;;){

               循环语句体                                        循环语句体 

             }                                                         }

for循环和while循环可能一次都不会执行,但是do-while语句无论满不满足条件都需要执行一次.

跳转语句

break:  结束所在层次的循环

continue:  结束所在循环,继续外层循环.

return   :结束方法

2.方法

          将一段具有特定功能的代码，使用大括号包围起来，起一个名字，加上一些权限和修饰，就是方法。以后使用这一段代码，只需要书写方法的名字调用.

      public static void getSum(int i){

}

格式:

                     权限修饰符  静态 返回值类型 方法名称(参数列表) {
                     方法体;
                     return语句;
                     }
           无返回值类型的返回值类型为void    return语句省略.

方法的调用:

               直接调用：直接书写方法名称调用方法，让方法执行
               输出调用：调用有返回值的方法，将具体返回的结果进行输出
               赋值调用：调用有返回值的方法，将返回结果赋值给对应类型的变量

           return 这个关键字用来结束方法 

          结合有具体返回值类型的方法的使用    返回方法指定类型的值,
无返回值时,省略return.

求三个数中最大的数.

import java.util.Scanner;
public class 3Number_max {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入三个数:");
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
     int max= max_number(a,b,c);
        System.out.println(max);
    }
    public static int  max_number(int a,int b, int c){
        int temp = (a>b)?a:b ;
        int result= (temp>c)?temp:c;
        return  result;
    }
    }

方法的重载:   overland

定义:
       在同一个类中,方法名相同,参数列表不同,与返回值类型无关

      相同功能,相同逻辑,但是参数列表不同的方法,使用相同的方法名,表示这一类方法,在传入参数的时候,通过不同的参数列表匹配不同的参数,自动匹配相对应的方法.
为了功能拓展性

方法的重载
//方法重载   方法名完全相同(大小写)  参数列表不同
//为了功能拓展性
public class overload_test {
    public static void main(String[] args) {
     /*   Scanner sc=new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();*/
        System.out.println( getSum(10,20));
        System.out.println( getSum(10,20,30));
        System.out.println( getSum(10,20,30,40));
    }
  public static int getSum(int a,int b){
        int result = a+b;
        return result;
  }
    public static int getSum(int a,int b,int c) {
        int result = a + b + c;
        return result;
    }
    public static int getSum(int a,int b,int c,int d) {
        int result = a + b + c + d;
        return result;
    }
}

方法的注意事项:

1.方法不能嵌套.

2.方法的先后没有区别,方法执行的先后顺序只会取决于调用的顺序.

3.方法可以嵌套调用,方法可以自己调自己.

4.方法如果有具体的返回内容,就写成return,结果返回给调用者,返回值是什么类型,就写对应的类型.

5.无返回值的方法可以省略return

1.数组

  定义:

       就是用于存储相同数据类型的数据的容器

格式:

动态格式:      

 数据类型[] 数组名称 = new 数据类型[数组容量];

静态格式:

 数据类型[] 数组名称 = {  数据  }

   注意:

         数组一旦创建，大小不可更改

         一种数据类型的数组，只能存储一种数据类型的数据

数组的内存理解:

 方法区:存储字节码对象,存储静态相关的内容和常量.

栈: 执行方法的区域,方法加载分配内存进栈.

堆:用于存储数组.对象等数据量较大的数据,这些数据一般为引用数据类型.

异常:

            数组索引越界异常
访问的索引超出了已有索引的范围.

             空指针异常
地址为空,堆内存中没有开辟空间.

数组的遍历:

       一个一个经历元素，所有的元素都访问一遍

数组索引的起点:  0    终点   :数组名称.length - 1 

遍历数组:


public class arr_bl {
    public static void main(String[] args) {
        int arr[] = {8,7,5,6,2,3};
        for (int i = 0; i < arr.length-1; i++) {
        }

        printArray(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]+", ");
            }
        }
    }
    }

数组的逆序

数组的倒置
public class array_reverse {
    public static void main(String[] args) {

        int arr[] = {1, 2, 3, 4, 5,};
       // System.out.println(arr.length);
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
       array_print(arr);
    }
    public static void array_print(int array[]) {
              System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i== array.length-1) {
                System.out.print(array[i]+"]");
            }else{
                System.out.print(+array[i]+", ");
            }
        }
    }
}

获取数组的最值.

package com.qf.Demo.HomeWork;

 判断最值.

import java.util.Scanner;

public class min_number {
    public static void main(String[] args) {
        System.out.println("请输入五个数:");
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        int d = sc.nextInt();
        int e = sc.nextInt();
        int arr []= {a,b,c,d,e};
       int m  =  maxNumber(arr);
        System.out.println(m);
    }
    private static int maxNumber(int [] arr) {
         int min = arr[0];
        for (int i = 0; i< arr.length-1; i++){
            if(min > arr[i]){
                min = arr[i];
            }
        }
        return min;
    }
}

冒泡排序法


/*
 两两比较,较大的值往后边放,第一次比较完毕,最大值出现在最大索引处;
   依次比较
*/
public class maopao {
    public static void main(String[] args) {
        System.out.println("排序后:");
        int arr[]={4,5,1,3,2,15};
        compare(arr);
        array_print(arr);
      }

    private static void compare(int[] arr) {
        for (int i = 0; i< arr.length-1; i++){     //控制循环次数      i < 0 ,1 ,2 ,3
            for (int j = 0; j < arr.length-1-i; j++) {  //  <arr.length-1  防止角标越界    元素比较次数
                if (arr[j]>(arr[j+1])){
              int temp = arr[j];
                arr[j] = arr[j+1];
                 arr[j+1]=temp;
                }
            }
            }
    }
    public static void array_print(int array[]) {
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i== array.length-1) {
                System.out.print(array[i]+"]");
            }else{
                System.out.print(+array[i]+", ");
            }
        }
    }
}

面向对象:

思想特点:
      更符合生活中的思想行为习惯
      让复杂的事情简单化
      由执行者变为指挥
三大特征:封装  继承  多态

类和对象:

 类是对具体事物的一些抽象认识,概括的是一类事物共性的属性和行为.抽象的概念

对象是一个真实存在的事物是属性和行为的具体表现,属性的载体,行为的执行者.

对象的创建和使用

对象是一个真实存在的事物是属性和行为的具体表现,属性的载体,行为的执行者.

对象当中存放的是对应类当中的非静态（除static修饰的）所有属性和方法。

静态方法属于整个类，会随着类只分配一次内存调用，对象也可调用。

格式  :   
类名 对象名 = new 类名();  Scanner sc = new Scanner(System.in);

访问:
       对象名.属性名

访问方法：
对象名.方法名(实参列表);

修改:
      对象名.属性名 = 属性值;

示例:


/* 学生事物
        属性：姓名，年龄，性别，发型
        行为：吃饭，抽烟，打游戏，学习Java  */

class Student {
     String name;
     int age;
     String sex;      //成员变量   类中方法外
public  void study(  ) {
    System.out.println("学习:javaEE");
}
public  void  game (String gameName) {
    System.out.println("游戏:"+gameName);  //csGo
    }
}
  class StudentTest{
    public static void main(String[] args) {
        Student s = new Student();
        s.name ="王盼盼";
        s.age = 23;
        s.sex = "男";
        System.out.println(s.name+","+s.age+","+s.sex);
        s.study();
        s.game("csGo");
    }
}

成员变量和局部变量的区别

成员变量 :是一个变量，定义在类中，属于类的成员，这种变量就叫做成员变量
局部变量:是一个变量，定义在方法中，属于方法的成员，对于类而言，方法只是一个部分，所以是局部。

内存时间不同，生命周期不同

成员变量：属于对象，随着对象的创建而创建，随着对象的消亡而消亡

局部变量：属于方法，随着方法的进栈而创建，随着方法的出栈而消亡

基本类型作为形式参数和引用类型(数组 类 接口)

    基本数据类型 :

随着方法的调用的结束而结束

形式参数的改变不会影响到 实际参数的数值.

引用数据类型:        

  String 字符串   引用类型   形式参数的改变不影响实际参数

引用类型作为形式参数传递:形式参数的改变直接影响实际参数的数值.

封装:

封装：隐藏事物的实现细节，对外提供公共的访问方式

封装好处：

             隐藏事物的实现细节

             提高了代码的复用性

             提高了安全性

private关键字

        private，关键字，含义：私有的；权限修饰符：           

          修饰成员变量

          修饰成员方法

    特点:被private修饰的成员变量以及成员方法只能在本类中访问

            可以修饰成员变量也可以修饰成员方法,就是为了外界不能直接访问.

           被private修饰的成员变量/成员方法可以间接的通过访问方法间接访问.

Getter和Setter

         当成员变量私有化之后，外界无法直接访问，所以需要提供对外公开的访问方式，来获取成员变量值和设置成员变量值。

手机事物
		属性：品牌，颜色，价格，内存
		行为：打电话，拍照，聊天

class  Phone {

    private String brand;
    private int price;
    private String color;
    private int Memory;
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public int getMemory() {
        return Memory;
    }
    public void setMemory(int memory)   {
        Memory = memory;
    }
    public  void  call(){
    System.out.println("打电话");
    }
    public  void message(){
        System.out.println("发短信");
    }
    public  void  game() {
    System.out.println("打游戏");
    }
    public void  movie(String name){
    System.out.println("电影名:"+name);
    }
    public void  show(){
        System.out.println(getBrand()+","+getColor()+","+getMemory()+","+getPrice());
    }
}
class  PhoneTest {
    public static void main(String[] args) {
        //测试手机类
        Phone s = new Phone();
           s.setBrand("华为");
           s.setMemory(512);
           s.setBrand("华为matex");
           s.setColor("黑色");
           s.call();
           s.message();
           s.game();
           s.movie("亮剑");
           s.show();
    }
}

面向CV编程...
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Javase 总结 week04
weixin_51429113的博客
08-21 260
JavaSE笔记.
JavaSE总结
Q_Q521的博客
02-15 926
以类的方式组织代码，以对象的组织封装数据。int age;//构造器，无参构造//有参构造：实例化对象初始值//一旦定义了有参构造，就一定要声明无参构造。
Javase 总结 week01
weixin_51429113的博客
07-30 162
Javase 总结 week01
Javase 总结 week03
weixin_51429113的博客
08-13 140
JavaSE 总结.
JavaSE总结笔记
今天你学Java了吗
06-01 400
跟着楠哥学Java Java基础笔记
javase知识点大全总结
热门推荐
赵宪福的博客
09-24 1万+
JAVASE知识点总结 Java基础语法 1.标识符 1.在java语言中，对各种变量，方法和类等要素命名时所使用的字符序列就是标识符。 这些标识符有jdk定义好的，也有我们自己开发时候需要定义的。 2.java中标识符由26个英文字符大小写，数字0-9，符号_ $。注意：数字不能开头。 3.java中是严格区分大小写 4.在实际写程序的过程中定义标识符遵守“见名之意”.  类名和接口的规范： ...
javaSE总结
ytyif的博客
01-15 232
第一部分 语法基础篇 第一章 概述 1.1计算机组成部分 计算机的组成主要分成两大类：硬件，软件 硬件是可以看到的一些物理部分，都是一些电子元件 软件是看不到的部分，它是一些列的指令，这些指令主要用于控制硬件来玩成一些特殊的工作 常见的硬件： .CPU;Cent Processing Unit是中央处理器 主要指控制和数值计算功能(日常工作任务） .内存；临时性存储设备RAM，当内存不通电的时候，这数据也就消失了 .显卡CPU;Grqphic processing Unit图形图像处理单元 主要用于计算图形
JAVASE总结
weixin_40211315的博客
04-01 3252
一：java概述（快速浏览）：1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器；1994年将Oak语言更名为Java； Java的三种技术架构:JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；JAVASE：Java Platfo...
【JavaSE总结】常用类
赵啸天的博客
01-16 197
一、Object类 1、hashcode() 获取变量的hashcode值 变量名.hashcode(); 2、toString() 获取对象相应的String类型对象 int a = 123; System.out.println(a.toString()); 这样输出的结果是123，但输出的是一个String类型的值。 3、clone() 完完全全复制一个对象，但是地址不同。 Person p = new Person(23, "zhang"); Person p1 = (Person) p.clo
JavaSE总结.xmind
04-14
JavaSE总结.xmind
javase总结
05-08
这份"javase总结"涵盖了Java语言的基础和核心概念，对于懒人学者来说，它提供了一条清晰的学习路径，无需在海量资料中寻找关键信息。以下是根据标题、描述和文件名提炼出的Java SE相关知识点： 一、Java基础 1. **...
javase总结.html
08-23
javase基础总结
javaSE总结.mmap
06-20
javaSE超级总结 ，用思维导图mindmanager制作mmap文件，javase部分的超级总结 ，手机可用mindjet maps 查看
JavaSe总结
01-29
本总结将深入探讨JavaSE中的核心概念和技术，帮助初学者建立起坚实的基础。 1. **基本语法与数据类型** - Java是一种静态类型的面向对象编程语言，强制类型检查确保了代码的稳定性。 - 数据类型分为基本类型（如...
【链表在Java中DeBug】
最新发布
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
08-19 233
时，你实际上是在告诉当前节点 cur：“你的下一个节点应该是这个新创建的节点。，你将 cur 的引用更新为新创建的节点，这样 cur 现在就指向了你刚刚添加到链表末尾的节点。实际上，head 是一个固定的引用，它始终指向链表的第一个节点（即头节点）。当你看到链表似乎“增长”了，这实际上是因为你通过操作 cur（当前节点的引用）在链表的末尾添加了新的节点。所以，当你看到链表“增长”时，你实际上是在通过更新节点之间的链接（即 next 指针）来扩展链表结构。它只是保持了对链表起始节点的引用。
Spring Boot实现简单的Oracle数据库操作
beautiful77moon的博客
08-18 415
使用到的技术：1. Spring Boot：用于简化Spring应用的开发。2. Dynamic DataSource：实现动态多数据源的访问和切换3. Oracle JDBC Driver：与Oracle数据库进行连接和交互。4. Mybatis-Plus：简化SQL映射和数据库访问。其中BaseMapper接口提供了对数据表进行基本操作的功能。5. Lombok：用于简化Java类的开发，自动生成常用的代码，比如getter、setter、构造函数等。
Linux配置Maven环境
Java全栈开发者
08-18 407
官网地址：https://maven.apache.org/download.cgi。获取其对应的下载链接（也可以使用下载到本地后，手动上传到服务器的方式）切到自己想要存放的路径后，使用wget下载。使用pwd查看文件路径，ll查看文件名称。这里以当前最新版本3.9.8为例。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 963
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
"JavaSE面向对象特性总结：封装、继承、多态
对于JavaSE知识点的总结，首先需要对面向对象的理解进行概括。面向对象是Java的基本特征，它是一种基于面向过程的思维方式，将功能封装进对象，强调具备功能的对象和调用结果，不关注具体实现这个功能的过程。面向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值