类和对象，以及 LeetCode 每日一题

所有类都是引用类型。

1 定义类

类是某一批对象的抽象。

1.1 定义类的语法：

1 [修饰符] class 类名{
2     零到多个构造器定义
3     零到多个成员变量
4     零到多个方法
5 }

对于一个类定义而言，可以包含三种最常见的成员：构造器、成员变量、方法

• 修饰符可以是 public、final 、 abstract ，或者完全省略修饰符。
• 类里各成员之间的定义顺序没有任何影响，各成员之间可以相互调用，需要指出的是，static 修饰的成员不能访问没有 static 修饰的成员。
• 构造器用于构造该类的实例，java语言通过 new 关键字来调用构造器从而返回该类的实例。构造器是创建对象的根本途径，如果程序员没有为一个类编写构造器，则系统会为该类提供一个默认的构造器。一旦程序员提供了构造器，系统不再为该类提供构造器。

1.2 定义成员变量

1 [修饰符] 类型 成员变量名 [= 默认值]；

• 修饰符可以省略，也可以是 public、protected、private、static、final，其中 public、protected、private 三个最多只能出现一个
• 类型可以是 java 语言允许的任何类型，包括基本类型和引用类型

1.3 定义方法

1 [修饰符] 方法返回值类型 方法名（形参列表）{
2     //方法体
3 }

• 修饰符可以省略，也可以是 public、protected、private、static、final、abstract，其中 public、protected、private 最多选一个，final 和 abstract 最多选一个。
• static 是一个特殊的关键字，它可用于修饰方法、成员变量等成员。static修饰的成员表面它属于这个类本身，而不属于该类的实例，静态（static）成员不能直接访问非静态成员。

1.4 构造器

1 [修饰符] 构造器名（形参列表）{
2     //构造执行体
3 }

• 修饰符可以省略，也可以是 public、protected、private 其中之一
• 构造器名必须与类名相同
• 构造器不能定义返回值类型，也不能用void声明

2 对象的产生和使用

• 创建对象的根本途径是构造器，通过 new 关键字可以调用某个类的构造器即可创造这个类的实例。

　　　　java 的对象有两个作用：

• • 访问对象的实例变量
  • 调用对象的方法
• 如果权限允许，类里定义的方法和成员变量都可以通过类或实例来调用：类.类变量|方法，或者实例.实例变量|方法。
• static 修饰的方法和成员变量，既可以通过类来调用，也可通过实例来调用；没有 static 修饰的普通方法和成员变量，只可通过实例来调用。
• this 引用，this 关键字总是指向调用该方法的对象。
• 如果调用 static 修饰的成员，忽略了前面的主调，那么默认使用该类作为主调；如果调用没有 static 修饰的成员时省略了前面的主调，那么默认使用this作为主调。

ps：如果方法里有个局部变量和成员变量同名，但程序又需要在该方法里访问这个被覆盖的成员变量，则必须用this前缀。

3 leetcode 练习题

题目：21. 合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

 1 /**
 2  * definition for singly-linked list.
 3  * public class listnode {
 4  *     int val;
 5  *     listnode next;
 6  *     listnode(int x) { val = x; }
 7  * }
 8  */
 9 class solution {
10     public listnode mergetwolists(listnode l1, listnode l2) {
11         listnode list = null;
12         if(l1 ==null && l2 == null){
13             return list;
14         }else if (l1 == null){
15             list = new listnode(l2.val);
16             l2 = l2.next;
17         }else if(l2 == null){
18             list = new listnode(l1.val);
19             l1 = l1.next;
20         }else{
21             if(l1.val > l2.val){
22                 list = new listnode(l2.val);
23                 l2 = l2.next;
24             }else{
25                 list = new listnode(l1.val);
26                 l1 = l1.next;
27             }    
28         }
29         listnode tmp = list;
30         while(l1 != null || l2 != null){
31             if(l1 == null){
32                 tmp.next = new listnode(l2.val);
33                 tmp = tmp.next;
34                 l2 = l2.next;
35             }else if(l2 == null){
36                 tmp.next = new listnode(l1.val);
37                 tmp = tmp.next;
38                 l1 = l1.next;
39             }else{
40                 if(l1.val < l2.val){
41                     tmp.next = new listnode(l1.val);
42                     tmp = tmp.next;
43                     l1 = l1.next;
44                 }else{
45                     tmp.next = new listnode(l2.val);
46                     tmp = tmp.next;
47                     l2 = l2.next;
48                 }
49             }
50             
51         }
52         return list;
53     }
54 }

这是第一次接触链表，第一步设置表头的时候有点笨拙，看到评论中的设置 dummyhead ，最后输出 dummyhead.next 的方法，可以使代码更简洁一点，但实际性能应该差不多，这道题我的答案执行用时 2 ms。另外还有另一种方案是将两个链表的节点重新串起来，这样耗费的内存会更小，速度也更快，缺点是原本的两条链表会被破坏，不能再次使用了。