JavaSE learning day06

稀疏数组

行（row)	列(col)	值（value)
3	3	2
0	1	10
1	1	2

3*3矩阵 有两个元素被赋值（默认值为0）

0 10 0

0 2 0

0 0 0

package Arrays;

import java.util.Arrays;

public class Demo4 {
    //书写一个棋盘，稀疏数组存储，无子表示为0 黑棋表示为-1 白棋表示为1
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];
        array1[2][5] = 1;
        array1[3][5] = -1;
        array1[9][9] = 1;
        System.out.println("输出原始棋盘：\n");
        printArray(array1);
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0)
                    sum++;
            }
        }
        System.out.println("有效值为" + sum);//计算稀疏数组元素
        //遍历二维数组将非零值存放在稀疏数组中
        int[][] xishu = new int[4][3];
        xishu[0][0] = 11;
        xishu[0][1] = 11;
        xishu[0][2] = sum;

        int count = 1;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    xishu[count][0] = i;
                    xishu[count][1] = j;
                    xishu[count][2] = array1[i][j];
                    count++;

                }
            }

        }
        System.out.print("输出稀疏数组\n");
        printArray(xishu);

        //稀疏数组还原
        System.out.println("还原棋盘");
        int[][] array2 = new int[xishu[0][0]][xishu[0][1]];
        for (int i = 1,j=0; i < xishu.length; i++) {
                array2[xishu[i][j]][xishu[i][j+1]]=xishu[i][j+2];
            }
        printArray(array2);

    }
    //方法类
    public static void printArray(int[][] array2){
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j]+" ");
            }
            System.out.println("\n");
        }
    }

}

OOP（Object-Oriented Programming,面向对象编程）

• 本质：以类的方式组织代码，以对象的组织（封装）数据

  三大特性：

  • 封装
  • 继承
  • 多态

  ---

  *** 面向过程与面向对象的区别***

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

  面向对象物以类聚采用分类的思维模式，思考问题先对问题进行分类，然后对每一类问题单独思考。最后。才对某个分类下的细节进行面向过程的思索，比较适合处理复杂的问题，适合处理需要多人协作的问题

package OOP;

public class Demo2 {
    // 静态方法
    public static void main(String[] args) {
        //静态方法的调用格式 类名.方法名称
        Student.say();
        //非静态方法 先生成实例化对象，然后采用对象名.方法名称调用
        Student student = new Student();
        student.say();

    }

}

静态类方法和类一起加载（早）当类存在时就已经存在了，而非静态类方法得等类实例化即创建对象之后才存在

public static void a(){

​ b();//不可访问

}

pubilc void b(){

}

java都是值传递

package OOP;

public class Demo2 {
    // 静态方法
    public static void main(String[] args) {
        //静态方法的调用格式 类名.方法名称
        Student.say();
        //非静态方法 先生成实例化对象，然后采用对象名.方法名称调用
        Student student = new Student();
        student.say();

        int a=1;
        change(a);
        System.out.println(a);//a的值没有改变

        Person person= new Person();
        System.out.println(person.sto);//null
        change(person);
        System.out.println(person.sto);//sto的值被改变



    }
 public static void change(int x){//值传递
        x=10;
 }
 public static void change(Person p){
        p.name="hjq";
        p.sto=100;
 }


}
class Person{
    String name;
    int sto;
}


1
0
100

idea打开项目结构详解，ctrl+shift+alt+s

构造器

作用

• 初始化类

  快捷键：alt+insert 快速生成构造器

  ctrl + a 全选变量

  OK

  若生成无参构造，选择select None

• 特点：

1、和类名相同

2、没有返回值

3、new本质在调用构造方法

4、初始化对象的值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SMobqrMz-1645546282666)(C:\Users\92088\Pictures\3.png)]构造器可以重载，如上图

封装、继承、多态

封装

• 高内聚、低耦合

alt + insert

选中setter and getter 分别对private成员进行初始化和输出访问。

package OOP;

public class Car {
    //封装核心，使用private
    private String name;
    private int sto;
    private int year;

    public Car(String name, int sto, int year) {
        this.name = name;
        this.sto = sto;
        this.year = year;
    }

    public Car() {};

    public String getName() {
        return name;
    }

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

    public int getSto() {
        return sto;
    }

    public void setSto(int sto) {
        this.sto = sto;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }
}

---

继承

• 继承是类与类之间的关系

• java中所有类的直接或间接继承object类

• 子类生成时默认调用父类无参构造、接着调用子类无参构造函数

  ---

  super

  1. super调用父类构造方法，必须在构造方法的第一个

  2. super只能出现在子类方法或构造方法中

  3. super和this 不能同时调用构造方法

  方法重写(关键词public)

  #son.java
  public static void test(){
          System.out.println("Son=>test");
      }
      
  #father.java
  public static void test(){
          System.out.println("Father=>test");
      }
  
  #application
  public static void main(String[] args) {
          Son son=new Son();
          son.test();
          Father son2=new Son();
          son2.test();//父类的引用指向子类，输出只跟左边创建对象的类有关
  
      }
   
  Son=>test
  Father=>test
  

修饰符范围：public > protected > default > private

抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException --> Exception()

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

为什么需要重写：

1、父类的功能，子类不一定需要，或者不一定满足！

alt + insert: override;

多态(同一方法根据发送对象的不同而采用多种不同的行为方式)

注意事项

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系，类型转换异常！ClassNotFoundException!
3. 存在条件：继承关系，方法需要重写
4. 父类的引用指向子类 Father f1 = new Son();

instanceof

instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。

简单记忆：x instanceof y 若x与y存在父子关系，那么结果为true/

Static关键字

• 非静态方法不能被加载到静态方法区中
• 静态方法可以访问静态方法
• 非静态方法可以访问静态方法（因为静态方法和类一起被加载，存在时间最早）

package OOP;

public class Demo4 {
    //static
    private static int age;//多线程中使用,静态变量
    private double score;//非静态变量

    public void run(){

    }

    public static void go( ){  }

    {
        System.out.println("匿名代码块");
    }

    static {
        System.out.println("静态代码块");
    }

    public Demo4() {
        System.out.println("构造方法");
    }

}



##main
package OOP;

public class Application {
    public static void main(String[] args) {
      Demo4 demo4 = new Demo4();
        System.out.println("========");
      Demo4 demo5 = new Demo4();


    }


}


output:
静态代码块
匿名代码块
构造方法
========
匿名代码块
构造方法

可见，静态代码块只执行一次，再该类第二个对象创建时，不会运行。

package OOP;

import static java.lang.Math.PI ;//静态导入包


public class Demo5 {
    public static void main(String[] args) {
        System.out.println(Math.random());
        System.out.println(PI);
    }
}

0.17234799063296413
3.141592653589793

• 被final修饰的类 不能被继承

---

抽象类

package Abstract;

public abstract class Demo1 {
    //约束~有人帮我们实现
    //abstract,抽象方法，只有方法名，没有方法实现
    public abstract void doSomething();
    //抽象类不能new 只能由子类实现。
}

//抽象方法只能存在抽象类中

package Abstract;
//抽象类的所有方法，继承了它的子类必须要实现它的方法。
public class Demo2 extends Demo1{

    @Override
    public void doSomething() {
        System.out.println("抽象类被Demo2定义");
    }
}

package Abstract;

public class application {    //抽象类在main中被调用的过程
    public static void main(String[] args) {
        Demo2 demo2 =new Demo2();
        demo2.doSomething();
    }
}