重生之我是java小白二

已于 2024-03-15 22:35:40 修改
阅读量716 收藏 20
点赞数 12
文章标签： java 开发语言
于 2024-02-29 20:48:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65909965/article/details/136286058
版权

一.类与对象

1.类

1.1创建类

class 类名

1.2成员变量

1.什么是成员变量

定义在类中方法外的变量叫成员变量

2.定义格式

数据类型 变量名;

这里的变量可以不用给值，也可以给值，如果不给值

int类型 默认为 0

double 默认为0.0

字符串 默认为 null

例如

int a;

1.3成员方法

1.什么是成员方法

在类中定义的方法

2.定义格式

权限修饰符 返回值类型 方法名(参数类型 参数名){

        方法体

        return 返回值

}

3.注意事项

a、如果成员方法没有返回值，则返回值类型可以用void代替

b、返回值类型要与方法返回值类型一致

2.对象

1.创建对象

1创建格式

类名 对象名=new 对象名;

2.访问对象属性与行为

1.访问对象属性

对象名.成员变量名;

2.访问对象行为

对象名.成员方法().

3.类与对象的几种实例(简单型)

3.1一个类一个对象

1.创建一个学生类，学生拥有学号，姓名，年龄，学生可以学习，吃饭，睡觉

2.创建一个学生对象

package com.shujia.day05;

/*
    学生：                        class Student:
        属性：学号，姓名，年龄             成员变量：id,name,age
        行为：学习，吃饭，睡觉             成员方法：study(),eat().sleep()

    手机：                               class Phone:
        属性：品牌  颜色  价格                  成员变量：brand  color price
        行为：打电话 给xxx发短信 打游戏           成员方法：call()  sendMessage(String n) playGame()
 */
public class Student {
    // 属性：
    // 成员变量：在类中方法外定义的变量，叫做成员变量
    // 数据类型 变量名; 对于成员变量而言，在定义的时候，可以手动赋值，也可以不给值，系统会赋予默认值。
    int id;
    String name;
    int age;

    //行为：成员方法
    //从此刻开始将之前的static去掉使用，只保留public
    public String study(){
        System.out.println("学习");
        return "java";
    }

    public void eat(){
        System.out.println("吃饭");
    }

    public void sleep(){
        System.out.println("睡觉");
    }
}

class StudentDemo1{
    public static void main(String[] args) {
        //根据编写好的类，创建第一个学生对象
        //语句定义格式：类名 对象名 = new 类名();
        Student s1 = new Student();

        //如何获取对象中的属性（成员变量）
        //语句定义格式：对象名.成员变量名;
        //获取学号
        int id = s1.id;
        System.out.println(id); // 0
        System.out.println(s1.name); // null
        System.out.println(s1.age); // 0

        s1.id = 1001;
        s1.name = "丁义杰";
        s1.age = 18;

        System.out.println(s1.id);
        System.out.println(s1.name);
        System.out.println(s1.age);

        //如何调用对象中的方法呢？
        //语句定义格式：
        //对象名.方法名();
        s1.eat();
        s1.eat();
        s1.eat();

        String res1 = s1.study(); // "java"
        System.out.println(res1);




    }
}

3.2两个引用指向同一个对象

package com.shujia.day05;

/*
    2个对象的内存图 其中有两个引用指向同一个对象

 */

class Phone {
    String brand;
    String color;
    int price;

    public void call() {
        System.out.println("打电话！");
    }

    public void sendMessage(String s) {

        System.out.println("发短信给 " + s);
    }

    public void playGame(){
        System.out.println("打游戏");
    }
}

public class PhoneDemo {
    public static void main(String[] args) {
        //创建第一个手机对象
        Phone p1 = new Phone();
        p1.brand = "华为mate60 pro";
        p1.color = "黑色";
        p1.price = 7999;

        System.out.println("品牌："+ p1.brand);
        System.out.println("颜色："+ p1.color);
        System.out.println("价格："+ p1.price);

        p1.call();
        p1.sendMessage("马云");
        p1.playGame();

        // 创建另一个引用，指向同一个对象
        Phone p2 = p1;
        p2.price = 5999;
        System.out.println("-------------------");
        System.out.println("品牌："+ p1.brand);
        System.out.println("颜色："+ p1.color);
        System.out.println("价格："+ p1.price);
        System.out.println("-------------------");
        System.out.println("品牌："+ p2.brand);
        System.out.println("颜色："+ p2.color);
        System.out.println("价格："+ p2.price);




    }
}

3.3匿名对象

1.什么叫匿名对象

是一种对象的简化方式

例如 p2=new Phone()

2.使用情况

a、对象调用方法仅仅使用一次

b、作为实际参数传递

3.4对象是引用数据类型

1.对象可以作为参数传递

形式   该类 该类new出来的对象名

2.当参数的类型是类的时候，调用他需要传入该类的对象

package com.shujia.day5;

class Teacher{
    public void fun1(int a,int b){
        System.out.println(a+b);
    }
    public void teach(){
        System.out.println("教学");
    }
}
public class TeacherDemo2 {
    public void show(Teacher t){ //类作为参数类型时，传入的是引入该类的对象
        t.teach(); //因为上面的数据类型是类，所以可以使用该类的成员方法
    }

}

class TeacherText1{
    public static void main(String[] args) {
        //创建Teacher对象
        Teacher teacher = new Teacher();
        teacher.fun1(4,5);
        //创建TeacherDemo2对象
        TeacherDemo2 teacherDemo2 = new TeacherDemo2();
        teacherDemo2.show(teacher);
    }
}

二.封装

1.相关概念知识

1.1概念

1.指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

1.2好处

1.隐藏实现细节，提供公共的访问方式

2.提高了代码的复用性

3.提高安全性

1.3封装原则

1.将不需要对外提供的内容都隐藏起来。

2.把属性隐藏，提供公共方法对其访问。

2.private关键字

2.1.相关知识

1.是一个权限修饰符。

2.可以修饰成员(成员变量和成员方法)

3.被private修饰的成员只在本类中才能访问。

2.2.private修饰成员变量的形式

1.private修饰的成员变量可以在本类中之间使用
package com.shujia.day6;
class Student1{
    private int a;
    public void get(int a){
        System.out.println(a);
    }

}
public class PrivateDemo2 {
    public static void main(String[] args) {
        Student1 student1 = new Student1();
        student1.get(3);
    }
}
2.private修饰的成员变量在其他类或者对象中使用

1.使用setXxx()方法进行赋值,这个是有参无返回值函数

2.使用getXxx()方法来进行获取，这个是无参有返回值函数

3.创建一个对象后用etXxx()方法进行赋值，输出用getXxx()方法

package com.shujia.day6;
class Teacher{
    private int age;
    private String name;

    //setAge()是有参无返回值的函数
    public void setAge(int a){
        age=a;
    }

    //getAge()是无参有返回值的函数
    public int getAge(){
        return age;
    }

    public void setName(String b){
        name=b;
    }

    public String getName(){
        return name;
    }
}
public class PrivateDemo3 {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        
        //赋值是通过setAge
        teacher.setName("zhansgan");
        teacher.setAge(18);
        
        //获取数据是getAge()
        System.out.println(teacher.getAge());
        System.out.println(teacher.getName());
    }
}

 同时这也是定义一个标准类的1.0版本

2.3private修饰成员方法

1.不能被对象直接使用

package com.shujia.day6;
class Teacher{
    private int age;
    private String name;

    //setAge()是有参无返回值的函数
    public void setAge(int a){
        age=a;
    }

    //getAge()是无参有返回值的函数
    public int getAge(){
        return age;
    }

    public void setName(String b){
        name=b;
    }

    public String getName(){
        return name;
    }

    private void show(){
        System.out.println("jiaoxue");
    }
}
public class PrivateDemo3 {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();

        //赋值是通过setAge
        teacher.setName("zhansgan");
        teacher.setAge(18);

        //获取数据是getAge()
        System.out.println(teacher.getAge());
        System.out.println(teacher.getName());
        teacher.show();
    }
}

这个Teacher类中的show方法被private修饰，而创建teacher对象中直接使用show方法是错误的，这个程序是报错的，接下来这样修改即可在对象中调用被private修饰的成员方法

package com.shujia.day6;
class Teacher{
    private int age;
    private String name;

    //setAge()是有参无返回值的函数
    public void setAge(int a){
        age=a;
    }

    //getAge()是无参有返回值的函数
    public int getAge(){
        return age;
    }

    public void setName(String b){
        name=b;
    }

    public String getName(){
        return name;
    }

    private void show(){
        System.out.println("jiaoxue");
    }

    public void getShow(){
        show();
    }
}
public class PrivateDemo3 {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();

        //赋值是通过setAge
        teacher.setName("zhansgan");
        teacher.setAge(18);

        //获取数据是getAge()
        System.out.println(teacher.getAge());
        System.out.println(teacher.getName());
        teacher.getShow();
    }
}

直接重新定义一个被public修饰的方法来接收show方法，那样再创建的对象中可以使用被public修饰的方法

3.this关键字

3.1相关知识

1.方法被哪个对象调用，this就代表那个对象

2.什么时候使用

a.局部变量隐藏成员变量

b.其他用法后面和super一起讲解

3.可以修饰成员变量也可以修饰成员方法

3.2使用

package com.shujia.day6;
class Teacher1{
    String name;
    int age;
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return this.age;
    }
}
public class ThisDemo1 {
    public static void main(String[] args) {
        Teacher1 teacher1 = new Teacher1();
        teacher1.setAge(19);
        teacher1.setName("xiaoming");
        System.out.println(teacher1.getAge());
        System.out.println(teacher1.getName());
    }
}

4.构造方法

4.1相关知识

1.构造方法作用概述

给对象的数据进行初始化

2.构造方法格式、

1.方法名与类名相同  类名(){方法体}

2.没有返回值类型，

3.连void都没有 没有具体的返回值

3.构造方法注意事项

1.如果你不提供构造方法，系统会给出默认构造方法

2.如果你提供了构造方法，系统将不再提供

3.构造方法也是可以重载的

4.2使用方法

1.创建对象时使用，立即使用

若有构造代码块，则后面new出来对象即可直接运行代码块的内容(内容看代码块)


package com.shujia.day6;



class Phone{
    private int price;
    private String brand;

    Phone(){
        System.out.println("这是无参的构造方法");
    }
    Phone(String s){
        System.out.println("这是有参的构造方法"+s);
    }
}
public class StructureDemo1 {
    public static void main(String[] args) {
        Phone phone = new Phone("aaa");
    }
}

创建对象时看你选择哪个构造方法 是无参还是有参

2.在有构造方法时不需要setXxx方法一样可以进行赋值
package com.shujia.day6;
class Teacher1{
    String name;
    int age;

    Teacher1(String  name,int age){
        this.age=age;
        this.name=name;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return this.age;
    }
}
public class ThisDemo1 {
    public static void main(String[] args) {
        Teacher1 teacher1 = new Teacher1("xiaom",18);
//        teacher1.setAge(19);
//        teacher1.setName("xiaoming");
        System.out.println(teacher1.getAge());
        System.out.println(teacher1.getName());
    }
}
3.java标准类的定义2.0版本

1、成员变量需要使用private关键字修饰

2、提供两个构造方法（无参构造方法/有参构造方法）

3、对每一个私有的成员变量提供公共的setXxx()和getXxx()

4、提供一个show方法，展示对象的成员变量值的情况（这个方法后面会被另外一个方法替换）

这个是通过setXxx赋值的

package com.shujia.day6;
class Phone1{
    private int price;
    private String brand;

    Phone1(){

    }
    Phone1(int price,String brand){
        this.brand=brand;
        this.price=price;
    }

    public void setPrice(int price){
        this.price=price;
    }
    public int getPrice(){
        return this.price;
    }
    public void setBrand(String brand){
        this.brand=brand;
    }
    public String getBrand(){
        return this.brand;
    }
    public void show(){
        System.out.println("价格是"+price+",品牌是"+brand);
    }
}

public class StructureDemo2 {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();
        phone1.setPrice(8888);
        phone1.setBrand("小米");
        phone1.show();
    }
}

这个是有参构造方法赋值

package com.shujia.day6;
class Phone1{
    private int price;
    private String brand;

    Phone1(){

    }
    Phone1(int price,String brand){
        this.brand=brand;
        this.price=price;
    }

    public void setPrice(int price){
        this.price=price;
    }
    public int getPrice(){
        return this.price;
    }
    public void setBrand(String brand){
        this.brand=brand;
    }
    public String getBrand(){
        return this.brand;
    }
    public void show(){
        System.out.println("价格是"+price+",品牌是"+brand);
    }
}

public class StructureDemo2 {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1(9999,"xiaomi");
//        phone1.setPrice(8888);
//        phone1.setBrand("小米");
        phone1.show();
    }
}

如果是只获取不赋值，可以把setXxx函数去除

5.几种成员方法

package com.shujia.day6;
class Phone2{
    public void func1(){
        System.out.println("这是无参无返回值的成员方法");
    }
    public void func2(String s){
        System.out.println("这是有参无返回值的成员方法");
    }
    public String func3(){
        System.out.println("这是无参有返回值的成员方法");
        return "无参有返回值";
    }
    public String func4(String s){
        System.out.println("这是有参有返回值的成员方法"+s);
        return s;
    }
}
public class FunctionDemo1 {
    public static void main(String[] args) {
        Phone2 phone2 = new Phone2();

        //无参无返回值的成员方法直接调用即可
        phone2.func1();

        //有参无返回值的成员方法赋值调用
        phone2.func2("hello");

        //无参有返回值的成员方法，如果想返回一个值的话 先定义一个变量介绍，或者直接打印这个方法
        String s1=phone2.func3();//定义变量接受
        System.out.println(phone2.func3());//直接打印这个成员方法

        //有参有返回值的成员方法，先要进行赋值，如果想返回一个值的话 先定义一个变量介绍，或者直接打印这个方法
        String s2=phone2.func4("nihao");//定义变量接受
        System.out.println(phone2.func4("nihao"));//直接打印这个成员方法
        
        System.out.println(s1);
        System.out.println(s2);
    }
}

6.类的初始化过程

加载Student.class文件进内存

在栈内存为s开辟空间

在堆内存为学生对象开辟空间

对学生对象的成员变量进行默认初始化

对学生对象的成员变量进行显示初始化

通过构造方法对学生对象的成员变量赋值

学生对象初始化完毕，把对象地址赋值给s变量

 7.static关键字

7.1相关知识

1.可以修饰成员变量和成员方法

2.static关键字特点

          a.随着类的加载而加载

          b.优先于对象存在(不需要创建对象就可以输出静态方法)

          c.被类的所有对象共享

          d.可以通过类名调用

3.static关键字注意事项

      a.在静态方法中是没有this关键字的，以及后面的super关键字

      b. 静态方法只能访问静态的成员变量和静态的成员方法(类变量)

package com.shujia.day6;
class Person{
    private String name;
    private int age;
    private static String guoJi;

    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;

    }

    public Person(String name, int age, String guoJi) {
        this.name = name;
        this.age = age;
        this.guoJi = guoJi;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGuoJi() {
        return guoJi;
    }

    public void setGuoJi(String guoJi) {
        this.guoJi = guoJi;
    }

    public void show(){
        System.out.println("姓名是"+name+",年龄是"+age+",国家是"+guoJi);
    }
}
public class StaticDemo1 {
    public static void main(String[] args) {
//        Person person = new Person();
//        person.setAge(18);
//        person.setName("李四");
//        person.setGuoJi("中国");
//        person.show();

        Person person1 = new Person("李四",18,"中国");
        Person person2 = new Person("王五",18);
        Person person3 = new Person("张三",20);
        person1.show();
        person2.show();
        person3.show();
    }
}

7.2成员变量被static修饰的

1.被static修饰的成员优先对象而存在于方法区中的静态区，并且有个默认值

package com.shujia.day6;
class Person{
    private String name;
    private int age;
    private static String guoJi;

    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;

    }

    public Person(String name, int age, String guoJi) {
        this.name = name;
        this.age = age;
        this.guoJi = guoJi;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGuoJi() {
        return guoJi;
    }

    public void setGuoJi(String guoJi) {
        this.guoJi = guoJi;
    }

    public void show(){
        System.out.println("姓名是"+name+",年龄是"+age+",国家是"+guoJi);
    }
}
public class StaticDemo1 {
    public static void main(String[] args) {
        


        Person person1 = new Person("李四",18,"中国");
        Person person2 = new Person("王五",18);
        Person person3 = new Person("张三",20);
        person1.show();
        person2.show();
        person3.show();
        
        /*运行结果
        姓名是李四,年龄是18,国家是中国
        姓名是王五,年龄是18,国家是中国
        姓名是张三,年龄是20,国家是中国
         */

    }
}

2.被static修饰的成员叫做类成员，将来可以直接使用类名进行访问，类名.类成员

package com.shujia.day6;
class Person{
    private String name;
    private int age;
    static String guoJi;

    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;

    }

    public Person(String name, int age, String guoJi) {
        this.name = name;
        this.age = age;
        this.guoJi = guoJi;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGuoJi() {
        return guoJi;
    }

    public void setGuoJi(String guoJi) {
        this.guoJi = guoJi;
    }

    public void show(){
        System.out.println("姓名是"+name+",年龄是"+age+",国家是"+guoJi);
    }
}
public class StaticDemo1 {
    public static void main(String[] args) {



        Person person1 = new Person("李四",18,"中国");
        Person person2 = new Person("王五",18);
        Person person3 = new Person("张三",20);
        person1.show();
        person2.show();
        person3.show();
        System.out.println(Person.guoJi);

        /*运行结果
        姓名是李四,年龄是18,国家是中国
        姓名是王五,年龄是18,国家是中国
        姓名是张三,年龄是20,国家是中国
        中国
         */

    }
}

7.3静态成员方法

1.非静态的成员方法，既可以访问非静态的成员变量，也可以访问静态的成员变量

package com.shujia.day6;
class Demo2{
    static int a=2;
    int b=3;
    public void show(){
        System.out.println(a);
        System.out.println(b);
    }
}
public class StaticDemo2 {
    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
        demo2.show();
        // 运行结果 2 3
    }
}

2.静态的成员方法，只能访问静态的成员变量/静态的成员方法

a.成员变量

package com.shujia.day6;
class Demo2{
    static int a=2;
    int b=3;
    public void show(){
        System.out.println(a);
        System.out.println(b);
    }
    public static void show1(){
        System.out.println(a);
//        System.out.println(b); 报错因为b是非静态成员变量，静态方法无法访问
    }
}
public class StaticDemo2 {
    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
//        demo2.show();
       demo2.show1(); //2
       Demo2.show1();//2
    }
}

b.成员方法

package com.shujia.day6;
class Demo2{
    static int a=2;
    int b=3;
    public void show(){
        System.out.println(a);
        System.out.println(b);
    }
    public static void fun(){
        System.out.println("这是静态成员方法");
    }
    public static void show1(){
        System.out.println(a);
//        System.out.println(b); 报错因为b是非静态成员变量，静态方法无法访问
//        show();报错因为show是非静态方法，静态方法无法调用
        fun();  //运行结果 这是静态成员方法
    }
}
public class StaticDemo2 {
    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
//        demo2.show();
       demo2.show1(); //2
       Demo2.show1();//2
    }
}

7.4main函数是静态函数

1.public 被jvm调用，访问权限足够大。

static 被jvm调用，不用创建对象，直接类名访问

void被jvm调用，不需要给jvm返回值

main 一个通用的名称，虽然不是关键字，但是被jvm识别

String[] args 以前用于接收键盘录入的

2.在main函数里面的方法只能是静态的

8.文档注释

1.工具类

1、构造方法私有化

2、方法必须是静态

下面就是一个工具类

package com.shujia.day6;


public class ToolDemo1 {
    public ToolDemo1() {
    }
    public static void printArray(int[] arr) {
        for (int index = 0; index < arr.length; index++) {
            if (index == 0) {
                System.out.print("[" + arr[index] + ",");
            } else if (index == arr.length - 1) {
                System.out.println(arr[index] + "]");
            } else {
                System.out.print(arr[index] + ",");
            }
        }
    }
    
}

这个是调用工具类

package com.shujia.day6;

public class JiSuanDemo1 {
    public static void main(String[] args) {
        int[] arr={11,22,334,55};
        ToolDemo1.printArray(arr);
    }
}

2.相关注释意思

1.@author  作者

2.@param arr  解锁这段代码的用处

package com.shujia.day06;

/**
 * @author 小虎
 * @version v1.0.0
 * 该类是数加小虎写的专门针对数组做操作的工具类，可以对数组进行逆序，排序，打印数据，获取数组最大值，最小值等等
 */
public class ArrayTool {
    private ArrayTool(){}

    /**
     * 可以对一个元素类型为int类型的一维数组进行打印
     * 以指定的格式输出
     * 举例：
     *  输出：[2,3,1,5,6]
     * @param arr 传入一个元素类型为int类型的一维数组
     */
    public static void printArray(int[] arr) {
        for (int index = 0; index < arr.length; index++) {
            if (index == 0) {
                System.out.print("[" + arr[index] + ",");
            } else if (index == arr.length - 1) {
                System.out.println(arr[index] + "]");
            } else {
                System.out.print(arr[index] + ",");
            }
        }
    }

    /**
     * 对一个元素类型为int类型的一维数组进行冒泡排序
     * @param arr 传入一个元素类型为int类型的一维数组
     * @return 返回一个排序后的数组，元素从小到大排序
     */
    public static int[] BubbleSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){  // 控制轮次
            for(int j=0;j<arr.length-i-1;j++){  // 控制每一轮的比较次数
                if(arr[j]>arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }

        return arr;
    }

    /**
     * 对一个元素类型为int类型的一维数组进行逆序
     * @param arr 传入一个元素类型为int类型的一维数组
     * @return 返回逆序后的数组
     */
    public static int[] niXu(int[] arr){
        for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
            int tmp = arr[start];
            arr[start] = arr[end];
            arr[end] = tmp;
        }
        return arr;
    }

    /**
     * 从一个元素类型为int类型的一维数组获取最大值
     * @param arr 传入一个元素类型为int类型的一维数组
     * @return 返回一个最大值
     */
    public static int getMaxNumber(int[] arr){
        //1、默认第一个元素为最大值和最小值
        int maxNumber = arr[0];

        //2、从第二个元素开始依次遍历，与最大值和最小值进行比较
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > maxNumber) {
                maxNumber = arr[i];
            }
        }
        return maxNumber;
    }


    /**
     * 从一个元素类型为int类型的一维数组获取最小值
     * @param arr 传入一个元素类型为int类型的一维数组
     * @return 返回一个最大值
     */
    public static int getMinNumber(int[] arr){
        //1、默认第一个元素为最大值和最小值
        int minNumber = arr[0];

        //2、从第二个元素开始依次遍历，与最大值和最小值进行比较
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < minNumber) {
                minNumber = arr[i];
            }
        }
        return minNumber;

    }

}

9.代码块

1概念

使用大括号将代码括起来的整体，叫做代码块

2.分类

1.局部代码块

a.概念:将{}括起来的整体，在方法的内部定义，叫做局部代码块,在同一个方法中多个局部代码块的执行顺序是自上而下执行

b.运行关系

1'单个代码块

package com.shujia.day6;

public class CodeDemo1 {
    public static void main(String[] args) {
        
        //局部代码块
        {
            int a=10;
            int b=20;
            System.out.println(a+b); //30
        }
    }

}

2'再代码块前面赋值

package com.shujia.day6;

public class CodeDemo1 {
    public static void main(String[] args) {
        int a=100;  
        //局部代码块
        {
            int a=10;  //这里出现错误是因为代码块前面已经给a赋值过了，且没有运行出去，这里改变不了a的值
            int b=20;
            System.out.println(a+b);
        }
        
    }

}

3'在代码块后面赋值

package com.shujia.day6;

public class CodeDemo1 {
    public static void main(String[] args) {
//        int a=100;
        //局部代码块
        {
            int a=10;
            int b=20;
            System.out.println(a+b); //30
        }
        int a=100;  //这里可以赋值是因为代码块里面的数值已经运行过了，在内存中已经释放了
        System.out.println(a);    //100

    }

}

4'多个代码块运行从上往下

2.构造代码块：

将{}括起来的整体，在类中方法外定义，叫做构造代码块 构造代码块 --> 构造方法

构造代码块,在每次创建对象的时候调用

1.创建对象时候调用

package com.shujia.day6;
class Code{
    {
        int a=60;
        System.out.println(60);
    }
}

public class CodeDemo1 {
    public static void main(String[] args) {
//        int a=100;
        //局部代码块
        {
            int a=10;
            int b=20;
            System.out.println(a+b); //30
        }
        int a=100;
        System.out.println(a);    //100

        Code code = new Code();   //60

    }

}

2.优先与构造方法先执行

package com.shujia.day6;
class Code{
    {
        int a=60;
        System.out.println(60);
    }

    public Code() {
        System.out.println("这是构造方法");
    }
}

public class CodeDemo1 {
    public static void main(String[] args) {
//        int a=100;
        //局部代码块
        {
            int a=10;
            int b=20;
            System.out.println(a+b); //30
        }
        int a=100;
        System.out.println(a);    //100  这是构造方法

        Code code = new Code();

    }

}
3.静态代码块：

将{}括起来的整体，在大括号前面加上static关键字，在类中方法外定义，叫做静态代码块

静态代码块--> 构造代码块 --> 构造方法

1.优先对象存在(不需要创建对象即可使用)

package com.shujia.day6;


public class CodeDemo1 {
    {
        int a=60;
        System.out.println(60);
    }

    public CodeDemo1() {
        System.out.println("这是构造方法");
    }
    static {
        System.out.println("这是静态代码块");
    }
    public static void main(String[] args) {


    }

}
//运行结果  这是静态代码块

2.静态代码块，在类加载的时候，就会执行一次，且只会在程序运行开始前运行一次，后续不会运行

package com.shujia.day6;


public class CodeDemo1 {
    {
        int a=60;
        System.out.println(60);
    }

    public CodeDemo1() {
        System.out.println("这是构造方法");
    }
    static {
        System.out.println("这是静态代码块");
    }
    public static void main(String[] args) {
        CodeDemo1 codeDemo1 = new CodeDemo1();
        CodeDemo1 codeDemo2 = new CodeDemo1();

    }

}
/*
运行结果
这是静态代码块
60
这是构造方法
60
这是构造方法
 */

3.静态代码块--> 构造代码块 --> 构造方法

package com.shujia.day6;


public class CodeDemo1 {
    {
        int a=60;
        System.out.println(60);
    }

    public CodeDemo1() {
        System.out.println("这是构造方法");
    }
    static {
        System.out.println("这是静态代码块");
    }
    public static void main(String[] args) {

           //局部代码块
        {
            int a=10;
            int b=20;
            System.out.println(a+b);
        }
        int a=100;
        System.out.println(a);
//
//        Code code = new Code();
        CodeDemo1 codeDemo1 = new CodeDemo1();
       

    }

}
/*
运行结果
这是静态代码块
30
100
60
这是构造方法
 */

分析  从main开始，优先静态代码块，所以输出"这是静态代码块"。紧接着局部代码块(从上往下执行),输出30，由接着普通语句输出100，后来new出来了一个对象，这个时候先执行构造代码块，输出60，然后执行构造方法，输出"这是构造方法"

Y 开心599
关注
  • 12
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java之重生我是CV架构师
05-12
Java之重生我是CV架构师
重生之我是软件大师的需求分析报告.pdf
10-19
重生之我是软件大师的需求分析报告.pdf
丧尸有危机 生化危机4重生之恶梦Java版评测.pdf
12-31
丧尸有危机 生化危机4重生之恶梦Java版评测.pdf
重生之我是赏金猎人(十二)-记一次与飞塔流量检测对抗的文件上传1
08-03
0x00 前如有技术交流或渗透测试/代码审计/红队向培训/红蓝对抗评估需求的朋友欢迎联系QQ/VX-5470066600x01 起因某项靶标，是个员管理系统，通
重生爬虫之笔趣阁小说<.>
04-24
"重生爬虫之笔趣阁小说"这样的表述可能是指利用网络爬虫技术从笔趣阁这样的小说网站上自动抓取重生题材小说资源的过程或工具描述。需要注意的是，这种行为涉及到了网络数据抓取与版权法的灰色地带。在大多数国家和...
自制植物大战僵尸：HTML5与JavaScript实现的简单游戏
m0_73367097的博客
06-08 1921
自制植物大战僵尸
简单的项目部署脚本（转载）
u010230019的博客
06-09 610
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1270
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 418
修改菜品——后端Java
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 413
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
【Java02】Java中数组的定义与初始化
饮冰室
06-10 522
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
KK爱Coding的博客
06-11 274
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
SpringBoot之请求映射原理
好记性不如烂笔头
06-12 1124
我们发出的请求，SpringMVC是如何精准定位到那个Controller以及具体方法？其实这都是 HandlerMapping 发挥的作用，这篇博文我们以 RequestMappingHandlerMapping 为例并结合源码一步步进行分析。默认 HandlerMapping 主要定义在和其祖父类中获取所有类型是 Object 的 beans，并且 beanName 不以开头根据 beanName 获取 beanType如果 beanType 上存在注解则进行处理。
微型操作系统内核源码详解系列四（3）：操作系统调度算法（FreeRTOS内核篇上）
最新发布
2301_77061352的博客
06-12 726
-uxTopPriority，被设定为是代表最大优先级的数字，自减操作代表从就绪列表最后一个链表（优先级最高的链表）开始查找，直到找到任务链表不为空的优先级任务，那么这个任务肯定也是所有任务中优先级最大的任务，然后获取这个任务的TCB并更新pxCurrentTCB（切换的具体函数），最后更新uxTopReadyPriority的值。容笔者说一下个人看法，从c语言和数据结构算法的层面学习，只能说是舍本逐末，透过Freertos这个小型系统，窥见庞大的操作系统架构的一角，这才是我们学习的重点。
Invalid keystore format，获取安全码SHA1值出错
yfy1907的博客
06-11 172
Invalid keystore format 错误
SpringBoot项目启动提示端口号占用
点滴汇聚，智在积累。——Danny
06-07 230
通过netstat查看当前端口号并没有被占用啊，那可能是使用了系统保留端口，通过。1、换个端口（不在系统保留端口的范围）于是换个端口号试试，还是提示占用。2、关闭hyper-v。
springboot连接多个库
sunyingboaini的博客
06-11 170
一个SpringBoot项目，同时连接两个数据库：比如一个是Mysql数据库，一个是oracle数据库（啥数据库都一样，连接两个同为oracle的数据库，或两个不同的数据库，只需要更改对应的driver-class-name和jdbc-url等即可）注意：连接什么数据库，要引入对应数据库的包。
【冲刺秋招，许愿offer】第 一 天
Panci_的博客
06-08 428
现在技术还是菜的一批，中等难度的算法题很难一次(一小时)解出来，项目稍微一深挖或者问点视频中没讲到的扩展性问题直接拉跨化身聋哑人，牛客面经越看越焦虑，里面问到的八股也不是都会，哎，感觉给我大厂面试机会也是秒挂，前面摆烂两个月了，秋招将至，再冲击一下，希望能拿到个好点的offer。逻辑过期：加一个字段来表示是否过期，业务逻辑变为，看判断是否过期，过期，获取锁，开启子线程进行缓存重建，其他线程以及主线哼返回旧数据。缓存击穿问题是由于热点Key过期了，导致大量请求到达数据库，可以用互斥锁或者逻辑过期。
解析final原理
2301_79437276的博客
06-10 182
final 变量的赋值通过 putfield 指令来完成，在这条指令之后也会加入写屏障，保证在其它线程读到它的值时。//final保证不能读到两个值。第三种：【不加final都算是在堆中，Getstatic速度小于上面两种】5: bipush 20 // 将值直接放入栈中。之前的修改、赋值操作之后会同步到主内存中去（可见性）大于 short（短整型） 最大值会将其复制到类的。之前的指令不会重排序到后面去（有序性）其他线程访问 final 修饰的变量。，访问时从常量池获取。
帮我生成一篇女频重生文大纲
02-17
好的，下面是一份女频重生文大纲，供您参考： 一、角色介绍 1. 女主角：原本是一名普通职场白领，因为某些原因不幸身亡，后来穿越到了另一个世界，重生为一个小家碧玉。 2. 男主角：身份高贵，是贵族公子，但内心孤独寂寞。与女主角的相遇成为了两人人生的转折点。 二、女主角的重生 1. 女主角重生为小家碧玉，开始了全新的人生。 2. 女主角意外获得前世记忆，开始重新规划自己的人生，决心不再让命运左右自己的命运。 3. 女主角遇到了男主角，两人开始产生微妙的情感变化。 三、女主角的成长 1. 女主角开始学习各种家教和礼仪，开始为自己的未来打算。 2. 女主角利用前世的知识和经验，开始寻找机会，逐渐展露出自己的才华和智慧。 3. 女主角在不断成长中，也逐渐发现了自己内心的情感，同时也逐渐发现了男主角的秘密。 四、男女主角的感情变化 1. 男主角开始被女主角的勇气和聪明才智所吸引，与女主角越来越亲近。 2. 女主角也开始对男主角产生了感情，但由于身份差异，两人之间的感情一度受到了阻碍。 3. 在各种磨难和考验之后，男女主角最终化解了彼此之间的矛盾，最终走到了一起。 五、故事结局 1. 男女主角在经历了各种波折后终于在一起，但是他们的未来之路仍然充满了挑战和不确定性。 2. 故事最终以一个带有悬念和期待的结局结束，让读者们自行想象二人之后的未来。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值