周报(0)

2018-12-01 周报 PV:

LeetCode：

简单思路：令i从0开始向后跑寻找与下标为length-1不相等的数，找到之后将那个数放到length的位置上，并且令length长度加1，最后返回length就行了。

代码部分：

int removeDuplicates(int* nums, int numsSize) {
if(numsSize==0){
    return 0;
}
int length = 1;
for(int i=0;i<numsSize;i++){
    if(nums[i]!=nums[length-1]){
        nums[length++]=nums[i];
    }
}
return length;
}

Java学习部分内容

重写与重载

重写：在子类中

1. 参数列表必须完全与被重写方法的相同
2. 返回类型必须与被重写方法的返回类型相同
3. 访问权限不能比父类中被重写的方法的访问权限更低。例如，父类的一个方法被申明为public，那么该子类中重写该方法就不能申明为protected。
4. 父类的成员方法只能被它的子类重写
5. 申明为final的方法不能被重写
6. 申明为static的方法不能被重写，但是能够被再次申明
7. 子类与父类在同一个包中，那么子类可以重写父类的所有方法，除了声明为private与final的方法
8. 子类与父类不在一个包中，那么子类只能够重写父类的声明为public和protected的非final方法
9. 构造方法不能被重写
10. 如果不能继承一个方法，则不能重写这个方法

super

1. 在父类的某一方法被重写后，如果需要调用原父类的方法，需在该方法前加super关键字

重载：在同一个类中

1. 被重载的方法必须改变参数列表（参数个数或类型不一样）
2. 被重载的方法可以改变返回类型
3. 被重载的方法可以改变访问修饰符
4. 被重载的方法可以声明新的或更广的检查异常
5. 方法能够在同一个类中或者一个子类中被重载
6. 无法以返回值类型作为重载函数的区分标准

区别点重载方法重写方法

参数列表必须修改一定不能修改

返回类型可以修改一定不能修改

异常可以修改可以减少或删除，一定不能抛出新的或者更广的异常

访问可以修改一定不能做更严格的限制（可以降低限制）

来自 http://www.runoob.com/java/java-override-overload.html

2.多态：同一个行为具有多个不同表现形式或形态的能力。

向上转型：子类引用的对象转换为父类类型称为向上转型。

重写式多态：也叫运行时多态，这种多态通过动态绑定技术来实现，是指在执行期间判断所引用的对象的实际类型调用起相应的方法。

Animal animal = new Cat(); //向上转型

1. 向上转型时，子类单独定义的方法会丢失。比如上面Dog类中定义的run方法，当animal引用指向Dog类实例时是访问不到run方法的，animal.run()会报错。
2. 子类引用不能指向父类对象。Cat c = (Cat)new Animal()这样是不行的。

向上转型后方法引用的优先级问题：

继承链中对象方法的调用的优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

注意：此时的（super）O 指的是O的父类。以下面的8为例：

b.show(C)

由于b的引用对象为B，所以可以调用的方法有：show(B)，show(A)
（this.show(O)）又b的类型也为B，所以方法也先在B中选择，发现没有show(C)方法
（super.show(O)）在B的父类，即A中查找show(C)方法，任然没有查找到
（this.show(super)O）原式为：b.show（C），又C的父类为B，所以该式变为：b.show(b)，并且在B中查找，找到了该方法，于是执行该方法，得到结果：B and B

实例
class A {
public String show(D obj) {
return (“A and D”);
}

public String show(A obj) {
    return ("A and A");
}

}

class B extends A{
public String show(B obj){
return (“B and B”);
}

public String show(A obj){
    return ("B and A");
}

}

class C extends B{

}

class D extends B{

}

public class Demo {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();

    System.out.println("1--" + a1.show(b));
    System.out.println("2--" + a1.show(c));
    System.out.println("3--" + a1.show(d));
    System.out.println("4--" + a2.show(b));
    System.out.println("5--" + a2.show(c));
    System.out.println("6--" + a2.show(d));
    System.out.println("7--" + b.show(b));
    System.out.println("8--" + b.show(c));
    System.out.println("9--" + b.show(d));
}

}
//结果：
//1–A and A
//2–A and A
//3–A and D
//4–B and A
//5–B and A
//6–A and D
//7–B and B
//8–B and B
//9–A and D

从4向后的解析原理：
当父类对象引用变量引用子类对象时，被引用对象的类型决定了调用谁的成员方法，引用变量类型决定可调用的方法。如果子类中没有覆盖该方法，那么会去父类中寻找。
Animal animal = new Cat(); //向上转型
Animal为引用对象
Cat为引用变量

首先，a2是类型为A的引用类型，它指向类型为B的对象。A确定可调用的方法：show(D obj)和show(A obj)。
a2.show(b) ==> this.show(b)，这里this指的是B。

然后.在B类中找show（B obj），找到了，可惜没用，因为show（B obj）方法不在可调用范围内，this.show(O)失败，进入下一级别：super.show(O)，super指的是A。

在A 中寻找show（B obj)，失败，因为没用定义这个方法。进入第三级别：this.show((super)O)，this指的是B。
在B中找show（（A）O）,找到了：show(A obj)，选择调用该方法。

输出：B and A

上面的例子简单的介绍了多态的意义，同一个行为具有不同的表现形式或形态的能力。

多态（重写式）实现的条件：

1. 继承（实现）
2. 重写
3. 向上转型

重载式多态：也叫编译时多态，也就是说这种多态在编译时已经确定好了。在调用这种方法时，通过传入不同的参数得到不同的结果。

此处重载式多态有不同的说法，部分观点认为：重载不属于多态，认为多态仅仅指的是在程序运行时根据不同的输入，而方法有不同的响应称之为多态；但重载指的是：在一个类里，方法名字相同，而参数不同。也就是说在程序编译时就确定了该方法的响应。所以不能称之为多态。关于这个部分，我还没有更深的理解，所以暂时保留意见。

Java学习部分内容

重写与重载

重写：在子类中

super

重载 ：在同一个类中

重载：在同一个类中