Java基础03

冒泡排序

比较数组中相邻得两个元素，如果第一个比第二个大，则交换位置，每一次比较，都会产生一个最大得数字，下一轮就可以少排一次，一次循环，直到结束。

   public int[] MySort (int[] arr) {
            // write code here
            int result = 0;
// 外部循环，从第一个数开始
            for (int i = 0; i < arr.length-1; i++) {
内部循环，比较相邻两个数
                for (int j = 0; j < arr.length-1-i; j++) {
// 交换位置
                    if (arr[j]>arr[j+1]) {
                        result = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = result;
                    }
                }

            }
            return  arr;

        }

稀疏数组

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

稀疏数组的处理方式：
1.记录数组一共有几行几列，有多少个不同值
2.把具有不同值得元素和行列及值记录在一个小规模数组中，从而缩小程序规模

稀疏数组得第一行表示其对应得数组是几行几列，里面有多少个不一样得元素，后面开始，表示每个元素再数组中的位置

面向对象

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

三大特性

1. 封装

封装是把客观事物抽象成类，并且把自己的属性和方法让可信的类或对象操作，对不可性的隐藏。

2. 继承

通过extends关键字，Java中类只有单继承，没有多继承，但是可以通过接口实现多继承

继承是类和类之间的关系，子类继承了父类，就会拥有父类的全部方法，以及非私有的东西

私有属性private

通过private 修饰的变量，就是私有属性，该属性被该变量所有，这样变量就不可以被外部类调用了

但是要想调用该变量，就要通过get/set方法

    private String name;
    private int age;
    // get/set方法
 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;
    }
//这样，外部类就可以使用该类的get/set方法来使用其私有属性

super关键字

super关键字：用于在子类中访问父类的变量方法等

/*
super关键字的用法有三种：
1.在子类的成员方法中，访问父类的成员变量。
2.在子类的成员方法中，访问父类的成员方法。
3.在子类的构造方法中，访问父类的构造方法。
 */
public class Zi extends Fu {
    int num = 20;
    public  Zi(){
        super();
    }
    public void  methodZi(){
        System.out.println(super.num); //父类中的num
    }
    public void method(){
        super.method(); //访问父类中的method
        System.out.println("子类方法");
    }
}

public class Fu {
    int num = 10;
    public void method(){
        System.out.println();
    }
}

super注意点

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

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

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

4. 多态

注意

1. 多态是方法的多态，属性没有多态
2. 多态存在的条件：继承关系，方法需要重写，父类引用指向之类对象
3. 使用父类类型的引用指向子类的对象
4. 该引用只能调用父类中定义的方法和变量，要想调用子类的方法，就要类型转换
5. 如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）

// 父类
public class Person {
    public void say(){
        System.out.println("hello");
    }
}

// 子类继承父类
public class Student extends Person{
    @Override // 重写父类方法
    public void say() {

        System.out.println("world");
    }

    public void sing(){
        System.out.println("sing");
    }
}

// Main方法
 public static void main(String[] args) {


        Student s1 = new Student();// 能调用自己的方法或者父类的方法
        // 父类的引用指向子类对象 但不能调用子类的方法
        Person s2 = new Student();
        /*
        这里s2属于person类型，它能调用子类student的sing()方法，但是可以调用自己的say()方法，由于say()方法被子类重写，
        所以执行子类的方法
        * */
        Person s3 = new Person();

        s1.say();
        s1.sing();
        s2.say(); // 子类一旦重写了父类的方法，执行子类的方法
       // s2.sing();
        s3.say();
        /*
        * 当父类中的一个方法只有在父类中定义而在子类中没有被重写的情况下，才可以被父类类型的引用调用； 对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。
        * */
    }

执行结果：

构造器

构造器也称构造方法，是在进行创建对象的时候必须调用的，并且有一下特点
1.必须和类名字相同
2.必须没有返回类型，也不能写void

构造器的作用

1.使用new关键字，本质是在调用构造器
2.用来初始化值
构造器分为有参构造和无参构造，无参构造可以不用写，但一旦定义了有参构造，想使用无参构造，无参构造就必须显示
继承也是一样的，父类定义了有参构造，而没有写明无参构造，那么子类也无法直接使用无参构造

public class Test {
    String name;
    // 无参构造
    public Test() {
    }
    // 有参构造
    public Test(String name){
        this.name = name;
    }
}

方法重写

重写都是方法的重写，和属性无关

子类继承了父类才能去重写父类的非静态方法

//父类
// 父类
public class Demo01 {
    private String name;
    public void say(){
        System.out.println(name+"father.say");
    }

    public String getName() {
        return name;
    }

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

//子类
// 子类
public class Demo02 extends Demo01{
    // 重写父类方法
    @Override
    public void say() {
//        super.say();
        System.out.println(getName()+"son.say");
    }
}

// Main方法
public class Main {
    public static void main(String[] args) {
//实例化一个子类对象
        Demo02 d2 = new Demo02();
        d2.setName("xiaoming");
        d2.say();
//实例化父类对象
        Demo01 d1 = new Demo01();
        d1.setName("d1");
        d1.say();
    }
}

结果显示：

总结：

1.需要有继承关系，子类重写父类的方法
2.方法名必须相同，参数列表必须相同（与重载区分）
2.修饰符，范围可以扩大，但是不能缩小，public--protect--default--private
3.抛出的异常，范围可以被缩小，但不能被扩大
3.子类方法和父类一致，方法体不同
为什么需要重写：
1.父类的功能子类不一定需要或者不一定满足

instanceof关键字

判断两个类之间是否存在父子关系

类型转换

1. 子类转换成父类 ，向上转型，自动转换
2. 父类转换成子类，向下转型，强制转换，可能会丢失一些方法

static关键字

非静态方法可以调用静态方法的东西，反之则不行
static 方法，只在类加载的时候执行一次，后面就不会执行
被final修饰的类不能被继承

抽象类

通过abstract修饰类名或方法，抽象类的所有方法，都要由继承它的子类来重写实现，除非子类也是抽象的

public abstract class Action {
// 抽象方法
    public abstract void sing();{}
// 普通方法
    public void song(){
        System.out.println("song");
    }
}

public  class A extends Action{
    @Override
    public void sing() {
        System.out.println("sing");
    }
}

注意*

不能new这个抽象类，但是存在构造方法，只能靠子类去实现约束它
抽象类里面可以存在普通方法，但是抽象方法只能在抽象类里面

接口

public interface UserService {

    public abstract void sum(int a,int b);

}

实现接口的类

public class UserServiceImpl implements UserService{
    @Override
    public void sum(int a, int b) {

    }
}

接口中的所有定义方法都是抽象的 public abstract（可以不写出来）
接口中没有构造方法
定义常量都是 public static final + int age...
接口都需要有实现类，实现类一般以impl结尾，通过implements
实现接口的类，必须要重写接口中的所有方法
Java是单继承，但是可以通过接口实现多继承