1.leetcode第二题

给定两个链表，逆序转换为数值相加，在逆序输出新链表。

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8
Explanation: 342 + 465 = 807.

思路：算法刚开始是最朴素的想法，先将链表转换为整型，然后相加后再转换成链表

while(it1.hasNext()){p=it1.next();  s1=s1+p*t1;t1*=10;}  //链表转整形,p是从低到高各单值，t代表10的次方。
while(s！=0){leave=s%10；s=s/10;}  //整形数分解，leave表示从低到高的各单值。

后来发现测试集有数据超过了int型，改为long型仍然有两个数据超过，改为BigInteger类对象，最后一个数据超级大N位的那种，于是开始改思路。

可以用各位分别相加来计算，然后保留进位，终于第9次Acceptance。

代码：

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {int flag=0;int s;s=(l1.val+l2.val+flag)%10;flag=(l1.val+l2.val+flag)/10;ListNode re=new ListNode(s);l1=l1.next;l2=l2.next;   //这一段的作用详见第3点while(l1!=null || l2!=null){if(l1==null){s=(l2.val+flag)%10;flag=(l2.val+flag)/10;ListNode newl=new ListNode(s);add(re,newl);l2=l2.next;}else if(l2==null){s=(l1.val+flag)%10;flag=(l1.val+flag)/10;ListNode newl=new ListNode(s);add(re,newl);l1=l1.next;}else{s=(l1.val+l2.val+flag)%10;flag=(l1.val+l2.val+flag)/10;ListNode newl=new ListNode(s);add(re,newl);l1=l1.next;l2=l2.next;}}if(flag==1){ListNode newl=new ListNode(1);add(re,newl);}return re;}void add(ListNode l,ListNode ll){if(l==null){l=ll;}while(l.next!=null){l=l.next;}l.next=ll;}

2.链表复习和BigInteger的初次接触

JAVA和C中的链表不同之处

JAVA中没有指针因此直接用类作为下节点引用：

class ListNode
{int val;ListNode next;ListNode(int x) { val = x; }
}

C：

typedef struct ListNode
{int val;struct ListNode *next;
}ListNode,*LinkList;   //C语言中结构体不管有没有typedef都有分号。

链表的遍历（简单）

while(l!=null)
{
//处理l.val
l=l.next;
}

链表的逆序遍历

if(l!=null)
{
if(l.next!=null)
{
//递归调用
}
//处理l.val
} //注意用if开始，while会陷入死循环。

一般来说使用long就足够，但有时见会遇到处理更大的数，这时我们就可以使用BigInteger对象，初始化BigInteger s=BigInteger.valueOf(10)

add(//BigInteger对象),subtract(),multiply(),divide()加减乘除操作。

divideAndRemainder()返回数组，第一个商，第二个余数。BigDecimal下次介绍。

3.遇见的问题

小问题1：文件名（类名）不能和引入的类名字相同。

小问题2：long超过int边界值后再强制转换为int会变成乱值。

Java的形参改变实参问题与C++的对比：

Java只能改变引用的值，只有类对象和数组（除去String和各基础类型(Integer、Double等)的引用）可以用作形参改变实参。

C++可以使用引用和指针。

只需再形参加上&引用符即可 声明形式void swap(int &a,int &b)，调用形式 swap(a,b) 。

声明 void swap(int *a,int *b){函数体使用*a,*b},调用swap(&a,&b),而Java中形式不变。

4.Java第三章 面向对象程序设计（一）

(1)基础：一个Java文件中至多有一个public类，且文件名要和public类名相同。若没有public类，则文件名可以和任一个类名相同。

垃圾回收机制：若一个实例对象没有任何引用指向，那么它所占的内存就会成为垃圾，但JVM一般不会立即回收，会在适合的时机回收垃圾，不保证先申请就先回收，也不保证先成为垃圾就先回收。若要想手动回收可以点用System.gc()方法，这样会调用类的finalize()方法，而系统在程序执行完回收则不会调用。

(2)继承:三大特性之一，一个类最多继承一个直接父类。

super()和this()方法:super()在子类的构造函数中调用，用于初始化类成员，必须写在构造函数第一句，若不含任何参数，则可以省略不写。值得注意，若父类没有构造函数，会创建一个默认的无参构造函数；若父类只有有参数构造函数，则默认构造函数不会产生，那么子类必须显示调用super且必须含参数;

而this()方法也是在构造函数中出现，必须写在第一行，所以与super()无法同时使用，用于调用其他重载构造方法。

上转型隐式调用：将子类对象复制给父类对象时成为上转型(upcasting),例如子类Square继承父类Shape,可以将父类的引用指向子类的对象，例如：Shape sh=new Square();

下转型显式调用：接上面语句，Square sq=(Square)sh;称为下转型(dwoncasting)，但不能直接使用这句，因为只有sh在指向子类对象时才能下转，否则编译不会出错，但运行会出错。

instanceof：判断对象是否是某类的实例，对于没有转型来说，子类是所有超类及自身的实例，返回true,例如Square sq=new Square();则sq instanceof Square，sq instanceof Shape乃至sq instanceof Object都返回true;而父类不会是子类的实例，例如Shape sh=new Shape()；sh instanceof Shape 返回true,但sh instanceof Square返回false;

对于上转型来说，父类便是子类的对象，例如 Shape sh=new Square();那么sh instanceof Square返回true;或者 Square sq=new Square(); Shape sh=sq;则sh instanceof Square,sh instanceof Shape,sq instanceof Square,sq instanceof Shape全都返回true;

对于下转型来说，由于父类肯定是上转型，所以不在讨论，子类与没有转型来说是相同的。

(3)多态:面向对象三大特征之一，分为静态多态，动态多态（即C++中的静态联编和动态联编）

静态多态：即重载(overload)，方法的名称相同但参数不同，例如各个构造函数。注意参数类型相同但参数名不同不算重载，仍是相同的函数。

动态多态：即覆盖(override)，指父类和子类方法参数类型和方法名完全相同，但JVM会识别出是哪一个调用。子类对象则调用子类方法，父类对象调用父类方法，上转型的父类调用子类方法，下转型的子类也调用子类方法。

super和this关键字：注意和前面super(),this()方法不相同，super可以使用在子类中非静态成员方法中用于访问父类型的成员，this用法与super相同，都是super.a,this.b,super.A(),this.B()形式，但是要调用本类的成员，主要用于区分局部变量和成员域（同名时），例如在很多set方法中都会有this.a=a类似的语句。

此外静态方法不具有动态多态性。

(4)包：包关键字package,必须是文件的第一句；

导入包语句有三种分别是：

import  wym.*；将整个wym包里的接口、类、枚举都导入。不会导入子包的类型。

import wym.Eat;将wym包中的Eat类型（接口、类、枚举其中之一）导入。

import static wym.Eat.main;将main静态方法导入。

第一种会增加程序开销，降低编译效率，尽量使用后两种。

(5)封装：三大特性之一

类的访问控制方式：pulic和默认(即什么修饰词也不加)，public的类可以被所有包使用（不同包需要用import导入，在同一包中可见），而默认类只能被包内使用（在同一包中可见）。

类成员访问控制方式：四种类型public,protected,默认，private。

对于public的类成员，所有能够访问该类的类型定义体都能访问访问该成员。

对于protected的类成员，若所在类是默认模式，则其他包的成员不能访问，若所在类是public，比default多了其他包的子类方法能够访问。

对于默认的类成员，同一软件包能够访问，但是不同包一定不能访问。

对于private的类成员，只有本类成员方法才能访问。

所在类为public时的权限：

所在类为默认时的权限：