关于java:类和objectso-easy啦

最近老是有小伙伴问类和 Object 相干的问题，感觉还是很多人对此不是很明确，那咱们明天就干掉这两个怪物。

Java 程序是由若干个类组成的，类也是面向对象编程思维的具体实现。

以下为类的定义：

public class User {
// 公有属性
private Long userId;
private String name;
private Integer age;
// 构造方法
public User() {
}
// 有残构造方法
public User(Long userId, String name, Integer age) {
this.userId = userId;
this.name = name;
this.age = age;
}

// 一般办法
public void say() {
System.out.println(“hello world”);
}
// 对外包装属性
public String getName() {
return this.name;
}
}

单类型导入

当咱们须要应用不同包下的类时，就须要应用 import 导入包或类，这个时候能力失常应用。例如，咱们要应用 java.util 下的 ArrayList 就必须应用 import java.util.ArrayList，代码如下：

// 导入 ArrayList 类
import java.util.ArrayList;
class Test {
public static void main(String[] args) {
ArrayList list = new ArrayList();
}
}

按需类型导入

如果咱们在同一个类中应用了同一个包上面的较多类时候，就会应用按需类型导入。

// 用到了 java.util 包目录下的 List、ArrayList 和 LinkedList 类
//import java.util.ArrayList;
//import java.util.LinkedList;
//import java.util.List;
// 如果不想类上有太多 import，就能够间接 import 包名.*
import java.util.*;
public class Test {
public static void main(String[] args) {
List list = new ArrayList<>();
List list1 = new LinkedList();
}
}

这个只是表象，其实也是一个一个的导入的，只是在代码层面看起来是一次性全副倒入了。

动态导入

import 还能够导入静态方法和动态域的性能，比方以下代码：

//精准导入
// 间接导入具体的动态变量、常量、办法办法，留神导入办法间接写办法名不须要括号。
import static com.assignment.test.StaticFieldsClass.staticField;
import static com.assignment.test.StaticFieldsClass.staticFunction;

// 或者应用如下模式：
// 按需导入 不用逐个指出动态成员名称的导入形式
//import static com.assignment.test.StaticFieldsClass.*;

public class StaticTest {
public static void main(String[] args) {
// 这里间接写动态成员而不须要通过类名调用
System.out.println(staticField);
staticFunction();
}
}

以上代码也能够顺利的执行，这也是 import 好玩的一个中央。

构造方法也叫结构器或构造函数，它的作用是类在进行初始化的时候会调用对应的构造方法，比方以下代码：

public class User {
// 公有属性
private Long userId;
private String name;
private Integer age;
// 构造方法
public User() {
}
// 有参构造方法
public User(Long userId, String name, Integer age) {
this.userId = userId;
this.name = name;
this.age = age;
}

// 一般办法
public void say() {
System.out.println(“hello world”);
}
public static void think() {
System.out.println(“thinking”);
}
// 对外包装属性
public String getName() {
return this.name;
}

构造方法五大准则

构造方法必须与类同名；
构造方法的参数能够没有或者有多个；
构造方法不能定义返回值（默认返回类型就是本类类型）；
每个类能够有一个或多个构造方法；
构造方法总是随同着 new 操作一起应用。

留神：如果勒种没有显示的定义构造方法，那么在编译的时候回默认为其增加一个无惨构造方法。构造方法理论开发中通常都是 public 润饰，还有就是咱们想要单例的状况下搞成 private 润饰。

Object 类是 Java 中的一个非凡类，它是所有类的父类，Java 中的类都间接或间接的继承自 Object 类。

Object 类的罕用办法如下：

equals()：比照两个对象是否雷同
getClass()：返回一个对象的运行时类
hashCode()：返回该对象的哈希码值
toString()：返回该对象的字符串形容
wait()：使以后的线程期待
notify()：唤醒在此对象监视器上期待的单个线程
notifyAll()：唤醒在此对象监视器上期待的所有线程
clone()：克隆一个新对象

对于更多 Object 的内容，如克隆（深克隆、浅克隆）、线程的几个罕用办法 wait、notify、notifyAll，对象比拟，对象的 hashCode 值等。

Java 中只反对单继承：即一个子类只能继承两个父类，而一个父类能够被多个子类继承。

每个人都只能有一个亲生父亲，一个父亲是能够有多个儿子的。

用法：应用 extends 关键字来实现类的继承，示例代码如下：

class Person {
public void say() {
System.out.println(“hello”);
}
}
public class User extends Person {
public static void main(String[] args) {
Person user = new User();
user.say();
}
}

以上程序执行后果：hello

继承的留神点

繁多继承性。（在 Java 中是不反对多继承的，艰深的说子类只能有一个父类，而父类能够有很多子类。）
反对多层继承。（继承能够始终传下去，子类有父类，父类又有父类 …)
如果父类成员应用 private 润饰, 那么子类不能被继承。（private 只是对本类无效）
如果一个子类继承了父类的属性和办法还能够有本人特有的属性和办法。（不光有父类的属性（可继承的）和办法（可继承的），也有本人独有的属性和办法。）
当子类和父类的成员变量重名的时候, 子类优先。（就近准则）

继承应用技巧

将公共的变量或者办法提取到超类中；
除非所有的办法都有继承的意义，否则不要应用继承；
在办法笼罩时不要扭转原有办法的预期行为。
个别在写代码的时候发现代码中存在反复代码, 须要向上抽取, 思考继承。
当某个类的设计非常复杂的时候能够思考继承

继承的长处

代码的可重用性。
应用继承能够轻松的定义子类。
父类的属性和办法能够用于子类中（非 private 润饰）。
设计应用程序变得更加简略。

设计模式中大量应用

比方：模板办法模式，就是采纳继承，子类本人去实现本人的业务逻辑。

关于java:类和objectso-easy啦

类介绍

关键字 import 的三种用法

构造方法

Object

继承