Day 06 Java基础04及数组、对象复习

Java基础04

数组复习

dataType[]arrayrefver = new datatype[arraysize];
int[] sb1=new int[10]//定义一个数组并采用动态初始化
int[] sb1={1,2,3};//静态初始化
man[] men = {new man(1,1),new man(2,2)};//静态初始化
arrays.length //获取数组长度，常见用于循环

Java内存

分为

• 堆：存放new的对象和数组、可以被所有的线程共享，不会存放别的对象引用
• 栈：存放基本变量类型（包含基本类型的具体数值）、引用对象的变量（会存放这个引用在堆里面的具体地址）
• 方法区：可以被所有的线程共享、包含了所有的class和static变量

---

二维数组

• 数组里面再嵌套数组

int a[][] = new int[2][5]//两行五列的数组

---

Arrays类

• 数组的工具类java,util.Arrays

imoport java.util.Arrays;
System.out.println(Arrays.toString(a));/打印数组全部内容
    
Arrays.sort(a);//数组进行排序
System.out.println(Arrays.toString(a));//并打印

import java.util.Arrays;
public class demo11 {
    public static void main(String[] args) {
        int[] sb1={456,4413,124,1234,7855};
        Arrays.sort(sb1);
        System.out.println(Arrays.toString(sb1));
    }
}
//自动排序且输出数组元素
//[124,456,1234,4413,7855]

• 查看JDK帮助文档
• Arrays类中的方法嗾使static修饰的静态方法，在使用的时候可以直接使用类名
• 给数组赋值：通过fill方法
• 对数组排序：sort方法，升序
• 比较数组：通过equals方法比较数组中的元素是否相等
• 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

import java.util.Arrays;
public class demo12 {
    public static void main(String[] args) {
        int[] a={1212,65,46,431,34,464,8};
        int[] big=big(a);//调用完我们自己写的排序方法后，返回一个排序后的数组
        System.out.println(Arrays.toString(big));
    }
     //降序
    public static int[] sort(int[] array){
        //临时变量
        int temp=0;
        //外层循环，判断我们要走多少次
        for (int i = 0 ; i < array.length-1; i++){
            //内层循环，比较两个数，如果num1>num2，交换位置
            boolean flag = flase;//通过flag标识位减少没有意义的比较
            for (int j=0; j< array.length-1-i;j++){
                if(array[j+1]>array[j]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flag = true;
                }
            }
            if(flag == flase){
                break;//优化结构，少算一步
            }
        }
        return array;
    }
     //升序
    public static int[] big(int[] array){
        //临时变量
        int temp=0;
        //外层循环，判断我们要走多少次
        for (int i = 0 ; i < array.length-1; i++){
            //内层循环，比较两个数，如果num1>num2，交换位置
            for (int j=0; j< array.length-1-i;j++){
                if(array[j+1]<array[j]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        return array;
    }
}//冒泡排序

import java.util.Arrays;
public class demo13 {
    public static void main(String[] args) {
        int[] sb ={121,214,5,1,2454,54,5454};
        Arrays.sort(sb);
        System.out.println(Arrays.toString(sb));
    }
}
//以上两种代码都为了实现同一功能，自动降序

---

//稀疏数组

---

面向对象

• 物以类聚，分类的思维模式，思考问题首先会解决需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索
• 面向对象适合处理复杂的问题，适合处理多人协作的问题
• 属性+方法=类
• 方法中写了return说明整个方法已经结束了
• return 后的值必须后方法名前面的返回值类型相同

方法的定义

• 修饰符
• 返回类型
• break
• 方法名
• 参数列表
• 异常抛出

方法的调用

• 静态方法
• 非静态方法
• 形参和实参
• 值传递和引用传递
• this关键字

---

• 类是一种抽象的数据类型，他对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
• 对象是抽象概念的具体实例
• 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

---

创建与初始化对象

• 使用new关键字创建对象

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

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

1.必须和类的名字相同

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

构造器必须要掌握

public class student{//创建学生类
    
}

package LEI;

public class DEMO01 {
    //属性：字段
    String name;
    int age;
    //方法：
    public void study(){
        System.out.println(this.name+"在学习");
    }
    //一个类中只可能存在属性和方法两个
}//创建类

package LEI;

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

        //类是抽象的，需要实例化
        //类实例化后会返回一个自己的对象
        //demo01对象就是一个DEMO01类的具体实例
        DEMO01 demo01 = new DEMO01();
        DEMO01 demo02 = new DEMO01();
        DEMO01 demo03 = new DEMO01();


        demo01.name="小明";
        demo01.age=18;

        System.out.println(demo01.name);
        System.out.println(demo01.age);

    }
}
//创建对象并赋值输出

---

构造器详解

• 一个类即是什么都不写，他也会存在一个方法
• 类中的构造器也成构造方法，是在进行创建对象的时候必须要调用的。构造器有以下两个特点

1. 必须和类的名字相同

2. 必须没有返回类型，也不能写void

构造器必须要掌握

public class person{
    String name;
    
    //实例化初始值
    //构造器的作用：1.使用new关键字，本质就是在调用构造器
    public Person(){
        
    }
    
    //有参构造：一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }
    
}

package lei2;

public class Person {
    String sbname;
    int sbage;

    public Person() {
    }

    public Person(String name23 , int age11){
        this.sbname=name23;
        this.sbage=age11;
    }
}//创建类

package lei2;

public class Application {
    public static void main(String[] args) {
        Person person1 = new Person("sb",23);


        System.out.println(person1.sbage);
    }
}//调用类

---

封装

• 高内聚，低耦合。

• 高内聚就是类的内部数据操作细节自己完成，不允许外部干涉

• 低耦合：仅暴露少量的方法给外部使用

• 封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏

属性私有，get/set

可以在封装的时候做一些检查

//类
public class student {

    private String name;//private:私有的
    private int id;
    private char sex;


    //获得这个数据
    public String getName(){
        return name;
    }
    //设置数据
    public void setName(String name){
        this.name = name;
    }
}

public class application {
    public static void main(String[] args) {
        student s1 = new student();

        s1.setName("nb");

        System.out.println(s1.getName());
    }
}

---

继承

• 子类继承了父类，就拥有父类的所有方法

  //基类，父类
  public class person {
  
      public void say(){
          System.out.println("我草你妈了个臭逼的");
      }
  }
  

  //学生 is 人   :派生类，子类
  public class student extends person {
  }
  

  public class application {
  
      public static void main(String[] args) {
          student s1 = new student();
  
          s1.say();
  
      }
  }
  

//public
//protected   权限比defalut高
//defalut
//private
//ctrl+h  打开继承树（前提在父类文件下）

• 在Java中，所有的类，都默认直接或者继承object

• Java中类只有单继承，没有多继承

• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖，组合，聚合等

  ---

  super

  • 可以与this进行对比

    public class student extends person{
        prtvate String name ="sb1";
        
        public void test(String name){
            System.out.printin(neme);//传递给输出的name
            System.out.printin(this.name);//输出类里面的
            System.out.printin(super.neme);//父级的
                
        }
    }
    

public class person{
    protected String name = "sb2";
   
}

super注意点：

• super调用父类的构造方法，必须在构造方法的第一个
• super必须只能出现在子类的方法或者构造方法总
• super和this不能同时调用构造方法

代表的对象不同：

this：本身调用着这个对象

super：代表父类对象的引用

前提

this：没有继承也可以使用

super：只能在继承条件下才可以使用

构造方法

this（）：本类的构造

super（）：父类的构造

---

方法重写

• 重写都是方法的重写，与属性无关
• 需要有继承关系，子类重写父类的方法

重写：

• 方法名必须相同

• 参数列表必须相同

• 修饰符：范围可以变大public>protected

• 抛出的异常 范围可以被缩小，但不能扩大

classnotfoundexcepttion 类找不到

exception范围大

• 重写 子类的方法和父类必须要一致，方法体不同

@override 重写的意思

如何重写？

ALT + INSERT

为什么需要重写？

• 父类的功能：子类不一定需要，或不一定满足