随笔day11

排序

  1. 冒泡排序：

​ 两层循环，外层冒泡轮数，里层依次比较

例：

package com.hanzhubing.array;

import java.util.Arrays;

//冒泡排序
//1.比较数组中，两个相邻的元素，如果第一个比第二个数大，就交换位置
//2.每一次比较都会产生一个最大和最小的数字，
//3.下一轮则可以少排序一次
//4.依次循环，直到结束
public class ArrayDemo07 {
    public static void main(String[] args) {
        int[]a={1,5,7,455,132,12,4521,1254,282,222,5613132};
        int[] sort = sort(a);

        System.out.println(Arrays.toString(a));


    }
    public static  int[] sort(int[]array){
        int temp=0;//临时变量temp
        boolean flag=false;
        //外层循环，判断要走多少次
        for (int i = 0; i < array.length-1; i++) {
            //内层循环，比较判断两个数的大小，然后交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j+1]<array[j]){
               temp =array[j+1];
               array[j+1]=array[j];
               array[j]=temp;
               flag=true;

                }

            }
            if (flag==false);{
            break;
            }


        }

        return array;

    }
}

稀疏数组

  1. 稀疏数组： 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存改该数组

  2. 稀疏数组的处理方式：

    • 记录数组一共有几行几列，有多少个不同值

    • 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

如图：

image-20220723231955548

面向对象

  1. 面向过程思想（线性思维）：

    • 步骤清晰简单，第一步做什么，第二部做什么
    • 面向过程适合处理一些较为简单的问题

  2. 面向对象思想

    • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，对某个分类下的细节进行面向过程的思索
    • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题

  3. 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路去分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理

什么是面向对象

  1. 面向对象编程（Object-Oriented Programming，oop）

  2. 面向对象编程的本质就是：**以类的方式组织代码，以对象的组织（封装）数据

  3. 抽象

  4. 三大特征：

    • 封装
    • 继承
    • 多态

  5. 从认识论角度去考虑是先有对象后有类；对象是具体的事物；类是抽象的，是对对象抽象

  6. 从代码运行的角度考虑是先有类后有对象，类是对象的模板

    方法的定义和调用

image-20220727153653691

例：

package com.hanzhubing.oop;
//引用传递：其本质还是值传递
//对象，内存
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);// null
        Demo05.change(person);
        System.out.println(person.name);//韩柱兵
    }
    public static void change(Person person){
        //person是一个对象：指向的是 Person person = new Person();这是一个具体的人，可以改变属性
        person .name="韩柱兵";
    }


}

//定义了一个person类，有一个属性交name
class  Person{
  String name; //默认为null
}

创建与初始化对象

类与对象的关系

  1. 类是一种抽象的数据类型，它是对某一类整体描述/定义，但是并不能代表某一个具体的事物

    如：动物、植物、手机、电脑等

    ​ Person类、Pet类、Car类等，这些类都是用来描 述/定义某一具体的事物应该具备的特点和行为

  2. 对象是抽象概念的具体实例

    如：张三就是人的一个具体实例，张三家里的旺财就是狗的一个实例

    能够体现出特点，展现出功能的是具体的实例， 而不是一个抽象的概念

  3. 使用new关键字创建对象

  4. 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及类中构造器的调用

  5. 类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点

    • 必须和类的名字相同

    • 必须没有返回类型，有不能写void

例：

package com.hanzhubing.oop.demo02;
//学生类
public class Student {
//属性：字段
    String name;//null
    int age ;//0

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

package com.hanzhubing.oop.demo02;
//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
//类：是抽象的，需要实例化 ，通过new创建对象
 //类实例化后会返回一个自己的对象
 //student这个对象就是Student类的一个具体的实例


        Student xiaoming=new Student();
        Student xiaogang=new Student();
        Student xiaohua=new Student();
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
        xiaoming.name="小明";
        xiaoming.age=23;
        xiaohua.name="小华";
        xiaohua.age=24;
        xiaogang.name="小刚";
        xiaogang.age=25;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
        System.out.println(xiaohua.name);
        System.out.println(xiaohua.age);
        System.out.println(xiaogang.name);
        System.out.println(xiaogang.age);






    }
}

构造器

package com.hanzhubing.oop.demo02;
//java经过编译生成class文件
public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
String name;
int age;


    //无参构造器作用：1.用来初始化值
    //2.使用new关键字，其实质是在调用构造器
  // 默认情况下 无参构造器
  public Person(){
   this.name="韩柱兵";


    }




//有参构造器：一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name="韩柱兵";
//alt+insert 生成构造器
    }
//方法重载
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

/*
//new 实例化了一个对象
        Person person = new Person();
        System.out.println(person.name);//null
        System.out.println(person.age);

 */
/* 总结：构造器的特点：
        1.必须和类名相同
        2.没有返回值
        作用：1.new关键字其实质是在调用构造方法
             2.初始化对象的值
        注意点：
        1.定义了有参构造后，如果想使用无参构造，需要显示一个无参构造
        alt+ insert 是生成构造方法的 快捷键
        this.=（this是当前对象的值）

 */

创建对象内存分析

package com.hanzhubing.oop.demo02;

import com.hanzhubing.oop.demo03.Pet;

//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {


        Pet dog = new Pet();
        dog.name="旺财";
        dog.age=3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);
        Pet cat = new Pet();
        

    }
}


package com.hanzhubing.oop.demo03;

public class Pet {
   public String name;
  public   int age;

   

    public void shout(){
        System.out.println("叫了一声");
    }
}

image-20220729222022481

posted @   Rookie小白韩  阅读(20)  评论(0)  编辑  收藏  举报
相关博文：
·  随笔day10
·  随笔day07
·  java入门
·  JAVA面向对象基础--面向对象介绍
·  日常学Java的笔记（四）-面向对象
阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列01：轻松3步本地部署deepseek，普通电脑可用
· 25岁的心里话
· 按钮权限的设计及实现
点击右上角即可分享
微信分享提示
AI IDE Trae