Object 类详解

Object 类基本特性

Object 类是所有类的父类，所有的 Java 对象都拥有 Object 类的属性和方法。

如果在类的声明中未使用 extends，则默认继承 Object 类。

【示例】Object 类

public class Person {...
}
//等价于：
public class Person extends Object {...
}

toString 方法

Object 类中定义有 public String toString()方法，其返回值是 String 类型。
Object 类中 toString 方法的源码为：

public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

【示例】重写 toString()方法

class Person {String name;int age;@Overridepublic String toString() {return name+",年龄：  " +age;}
}
public class Test {public static void main(String[ ] args) {Person p =new Person();p.age=20;p.name="李东";System.out.println("info:" +p);Test t = new Test();System.out.println(t);}
}

运行结果：

==和 equals 方法

“ ==”代表比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。
equals()提供定义“对象内容相等”的逻辑。比如，我们在公安系统中认为 id 相同的人就是同一个人、学籍系统中认为学号相同的人就是同一个人。
equals()默认是比较两个对象的 hashcode。但，可以根据自己的要求重写 equals 方法。

【示例】自定义类重写 equals()方法

public class TestEquals {public static void main(String[ ] args) {Person p1 = new Person(123, "吴嗲");Person p2 = new Person(123, "吴小雅");System.out.println(p1 ==p2);        //false，  不是同一个对象System.out.println(p1.equals(p2));   //true，  id相同则认为两个对象内容相同 String s1 = new String("尚学堂");String s2 = new String("嗲嗲工作室");System.out.println(s1 ==s2);               System.out.println(s1.equals(s2));}
}
class Person {int id;String name;public Person(int id,String name) { this.id=id;this.name=name;}  public boolean equals(Object obj) {if(obj = = null){return false;}else {if(obj instanceof Person) {Person c = (Person)obj;if(c.id==this.id) {return true;}}}return false;}
}

JDK 提供的一些类，如 String、 Date、包装类等，重写了 Object 的 equals 方法，调用这些类的 equals 方法， x.equals (y) ，当 x 和 y 所引用的对象是同一类对象且属性内容相等时 (并不一定是相同对象) ，返回 true 否则返回 false。

super 关键字

super “可以看做”是直接父类对象的引用。可通过 super 来访问父类中被子类覆盖的方法或属性。
使用 super 调用普通方法，语句没有位置限制，可以在子类中随便调用。
在一个类中，若是构造方法的第一行没有调用 super(…)或者 this(…); 那么 Java 默认都会调用 super(),含义是调用父类的无参数构造方法。

【示例】 super 关键字的使用

public class TestSuper01 {public static void main(String[ ] args) {new ChildClass().f();}
}
class FatherClass {public int value;public void f(){value = 100;System.out.println ("FatherClass.value=" +value);}
}
class ChildClass extends FatherClass {public int   value;public int   age;public void f() {super.f();   //调用父类的普通方法value = 200;System.out.println("ChildClass.value=" +value); System.out.println(value);System.out.println(super.value); //调用父类的成员变量 }public void f2() {System.out.println(age);  }
}

运行结果：

继承树追溯

· 属性/方法查找顺序：(比如：查找变量 h)
 查找当前类中有没有属性 h
 依次上溯每个父类，查看每个父类中是否有 h，直到 Object
 如果没找到，则出现编译错误。
 上面步骤，只要找到 h 变量，则这个过程终止。
· 构造方法调用顺序：
构造方法第一句总是：super(…)来调用父类对应的构造方法。所以，流程就是：先向上追溯到 Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止。
注：静态初始化块调用顺序，与构造方法调用顺序一样，不再重复。

【示例】继承条件下构造方法的执行过程

public class TestSuper02 { public static void main(String[ ] args) { System.out.println("开始创建一个ChildClass对象......"); new ChildClass(); }
}
class FatherClass { public FatherClass() {      System.out.println("创建FatherClass"); }
}
class ChildClass extends FatherClass {public ChildClass() {System.out.println("创建ChildClass"); }
}

运行结果：

封装(encapsulation)

封装是面向对象三大特征之一。
我们程序设计要追求“高内聚，低耦合”。
（高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；
低耦合是仅暴露少量的方法给外部使用，尽量方便外部调用。）

编程中封装的具体优点：
口提高代码的安全性。
口提高代码的复用性。
口 “高内聚”：封装细节，
便于修改内部代码，提高可维护性。口 “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。

封装的实现—使用访问控制符

Java 是使用“访问控制符”来控制哪些细节需要封装，哪些细节需要暴露的。 Java 中 4 种“访问控制符”分别为 private、default、 protected、 public。

【注】关于 protected 的两个细节：

若父类和子类在同一个包中，子类可访问父类的 protected 成员，也可访问父类对象的 protected 成员。
若子类和父类不在同一个包中，子类可访问父类的 protected 成员，不能访问父类对象的 protected 成员。

封装的使用细节

开发中封装的简单规则:
口属性一般使用 private 访问权限。属性私有后，提供相应的 get/set 方法来访问相关属性，这些方法通常是 public 修饰的，以提供对属性的赋值与读取操作 (注意： boolean 变量的 get 方法是 is 开头!) 。
口方法：一些只用于本类的辅助性方法可以用 private 修饰，希望其他类调用的方法用 public 修饰。

【示例】JavaBean 的封装演示

public class Person {// 属性一般使用 private 修饰private String name;private int age;private boolean flag;// 为属性提供 public 修饰的 set/get 方法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;}public boolean isFlag() {// 注意：  boolean 类型的属性 get 方法是 is 开头的 return flag;}public void setFlag(boolean flag) {this.flag = flag;}
}

【示例】封装的使用

class Person {private String name;private int age;public Person() {}public Person(String name, int age){this.name = name;// this.age = age;//构造方法中不能直接赋值，  应该调用 setAge 方法setAge(age);}public void setName(String name) {this.name = name;}public String getName() {return name;}public void setAge(int age) {//在赋值之前先判断年龄是否合法if (age > 130 || age < 0) {this.age = 18;//不合法赋默认值 18} else {this.age = age;//合法才能赋值给属性 age}}public int getAge() {return age;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}
}
public class Test2 {public static void main(String[ ] args) {Person p1 = new Person();//p1.name = "小红"; //编译错误//p1.age = -45;   //编译错误p1.setName("小红");p1.setAge(-45);System.out.println(p1);Person p2 = new Person("小白", 300);System.out.println(p2);}
}

运行结果：

多态(polymorphism)

多态指的是同一个方法调用，由于对象不同可能会有不同的行为。

多态的要点：

多态是方法的多态，不是属性的多态（多态与属性无关）。

多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。

父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

【示例】多态和类型转换

class Animal { public void shout() {                 System.out.println("叫了一声！"); }
}
class Dog extends Animal { public void shout() {        System.out.println("旺旺旺！"); }
}public void seeDoor() {            System.out.println("看门中...."); }
}
class Cat extends Animal { public void shout() {    System.out.println("喵喵喵喵！"); }
}
public class TestPolym { public static void main(String[ ] args) { Animal a1 = new Cat(); // 向上可以自动转型 //传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。 animalCry(a1); Animal a2 = new Dog(); animalCry(a2);//a2 为编译类型，Dog 对象才是运行时类型。 /*编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。 * 否则通不过编译器的检查。*/ Dog dog = (Dog)a2;//向下需要强制类型转换 dog.seeDoor(); }// 有了多态，只需要让增加的这个类继承 Animal 类就可以了。 static void animalCry(Animal a) { a.shout(); }/* 如果没有多态，我们这里需要写很多重载的方法。 * 每增加一种动物，就需要重载一种动物的喊叫方法。非常麻烦。 * static void animalCry(Dog d) { *     d.shout(); * }* static void animalCry(Cat c) { *    c.shout(); * }*/
}

运行结果：

如上示例，给大家展示了多态最为多见的一种用法，即父类引用做方法的形参，实参可以是任意的子类对象，可以通过不同的子类对象实现不同的行为方式。
由此，我们可以看出多态的主要优势是提高了代码的可扩展性。但是多态也有弊端，就是无法调用子类特有的功能，比如，我不能使用父类的引用变量调用 Dog 类特有的 seeDoor()方法。

对象的转型(casting)

父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。

向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型。

【示例】对象的转型

public class TestCasting {public static void main(String[ ] args) {Object obj = new String("小迪工作室"); //  向上可以自动转型// obj.charAt(0) 无法调用。编译器认为 obj 是 Object 类型而不是 String 类型 /* 编写程序时，  如果想调用运行时类型的方法，  只能进行强制类型转换。* 不然通不过编译器的检查。    */String str = (String) obj; //  向下转型        System.out.println(str.charAt(0)); // 位于 0 索引位置的字符          System.out.println(obj = = str); // true.他们俩运行时是同一个对象}
}

运行结果：

在向下转型过程中，必须将引用变量转成真实的子类类型(运行时类型) 否则会出现类型转换异常 ClassCastException。
【示例】类型转换异常

public class TestCasting2 {public static void main(String[ ] args) {Object obj = new String("北京尚学堂");//真实的子类类型是 String，  但是此处向下转型为 StringBufferStringBuffer str = (StringBuffer) obj;System.out.println(str.charAt(0));}
}

运行结果：

为了避免出现这种异常，我们可以使用 instanceof 运算符进行判断。

【示例】向下转型中使用 instanceof

public class TestCasting3 {public static void main(String[ ] args) {Object obj = new String("小迪工作室");if(obj instanceof String){String str = (String)obj;System.out.println(str.charAt(0));}else if(obj instanceof StringBuffer){StringBuffer str =(StringBuffer) obj;System.out.println(str.charAt(0));}}
}

抽象类

抽象方法和抽象类

· 抽象方法

使用 abstract 修饰的方法，没有方法体，只有声明。
定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。

· 抽象类
包含抽象方法的类就是抽象类。
通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

【示例】抽象类和抽象方法的基本用法

//抽象类
abstract class Animal {abstract public void shout();   //抽象方法
}
class Dog extends Animal {//子类必须实现父类的抽象方法，  否则编译错误public void shout() {System.out.println("汪汪汪！  ");}public void seeDoor(){System.out.println("看门中....");}
}
//测试抽象类
public class TestAbstractClass {public static void main(String[ ] args) {Dog a = new Dog();a.shout();a.seeDoor();}
}

抽象类的使用要点:

有抽象方法的类只能定义成抽象类

抽象类不能实例化，即不能用 new 来实例化抽象类。

抽象类可以包含属性、方法、构造方法。但是构造方法不能用来 new 实例，只能用来被子类调用。

抽象类只能用来被继承。

抽象方法必须被子类实现。

接口 interface

接口就是一组规范 (就像我们人间的法律一样) ，所有实现类都要遵守。

（面向对象的精髓，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如 C++、Java、C#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。）

接口的作用

· 为什么需要接口?接口和抽象类的区别?
接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。
（接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。）

接口和实现类不是父子关系，是实现规则的关系。
比如：我定义一个接口 Runnable，Car 实现它就能在地上跑，Train 实现它也能在地上跑，飞机实现它也能在地上跑。就是说，如果它是交通工具，就一定能跑，但是一定要实现 Runnable 接口

如何定义和使用接口

声明格式：

[访问修饰符] interface     接口名 [extends 父接口 1，父接口 2…] { 常量定义；方法定义；}

定义接口的详细说明：
 访问修饰符：只能是 public 或默认。
 接口名：和类名采用相同命名机制。
 extends：接口可以多继承。
 常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。
 方法：接口中的方法只能是：public abstract。省略的话，也是 public abstract。

要点
 子类通过 implements 来实现接口中的规范。
 接口不能创建实例，但是可用于声明引用变量类型。
一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是 public 的。
 JDK1.8（不含8）之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。
 JDK1.8（含 8）后，接口中包含普通的静态方法、默认方法。

【示例】接口的使用

public class TestInterface {public static void main(String[ ] args) { Volant volant = new Angel();      volant.fly(); System.out.println(Volant.FLY_HIGHT); Honest honest = new GoodMan(); honest.helpOther(); }
}/**飞行接口*/
interface Volant { int FLY_HIGHT = 100; // 总是：public static final 类型的； void fly(); //总是：public abstract void fly();
}
/**善良接口*/
interface Honest { void helpOther();
}
/**Angel 类实现飞行接口和善良接口*/
class Angel implements Volant, Honest{          public void fly() {     System.out.println("我是天使，飞起来啦！"); }public void helpOther() { System.out.println("扶老奶奶过马路！"); }
}
class GoodMan implements Honest { public void helpOther() {     System.out.println("扶老奶奶过马路！"); }
}
class BirdMan implements Volant { public void fly() {       System.out.println("我是鸟人，正在飞！"); }
}

接口中定义静态方法和默认方法(JDK8)

JAVA8 之前，接口里的方法要求全部是抽象方法。
JAVA8 (含 8) 之后，以后允许在接口里定义默认方法和静态方法。

-JDK8 新特性_默认方法

JAVA8 以后，我们也可以在接口中直接定义静态方法的实现。这个静态方法直接从属于接口 (接口也是类，一种特殊的类) ，可以通过接口名调用。

如果子类中定义了相同名字的静态方法，那就是完全不同的方法了，直接从属于子类。可以通过子类名直接调用。

public class Test {public static void main(String[] args) {A.staticMethod();Test_A.staticMethod();}
}
interface A {public static void staticMethod(){System.out.println("A.staticMethod");}
}
class   Test_A implements   A {public static void staticMethod(){System.out.println("Test_A.staticMethod");}
}

静态方法和默认方法

本接口的默认方法中可以调用静态方法。

public class Test {public static void main(String[] args) {A a = new Test_A();a.moren();}
}静态方法和默认方法 interface A {public static void staticMethod(){System.out.println("A.staticMethod");}public default void moren(){staticMethod();System.out.println("A.moren");}
}
class   Test_A implements   A {public static void staticMethod(){System.out.println("Test_A.staticMethod");}
}

接口的多继承

接口支持多继承。和类的继承类似，子接口 extends 父接口，会获得父接口中的一切。

【示例】接口的多继承

interface A {void testa();
}
interface B {void testb();
}
/**接口可以多继承：  接口 C 继承接口A 和 B*/
interface C extends A, B {void testc();
}
public class Test implements C { public     void testc() {}public void testa() {}public void testb() {}
}

JAVA入门——lesson 7相关推荐

Java入门培训班怎么选择
想要学习java技术,小编一直给小伙伴推荐的是报班学习,目前市面上的java培训机构有很多,对于java培训班的选择很多小伙伴都比较迷茫,下面小编就为大家详细的介绍一下Java入门培训班怎么选择的问题 ...
Java入门学习注意事项有哪些?
想要学好java技术,做好学习规划路线和注意事项是非常重要的,尤其是零基础学员,Java涉及到的知识点非常多,我们需要制定合理的Java学习路线图,这样会事半功倍,下面小编和大家总结一下Java入门学 ...
Java实用教程笔记 Java入门
Java入门 JDBC Java数据库连接,(Java Database Connectivity,简称JDBC)是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口,提供了诸如查询和更新 ...
Java入门（一）：Hello World !
前言从今天开始,准备写Java Web开发的系列文章,毕竟自己主攻的还是Java方向,Python只是业余学习的兴趣使然,在第二技能还没有培养成熟前,做好第一技能的巩固和提高是很有必要的.从正式入行 ...
《Java入门经典（第7版）》—— 6.11 练习
本节书摘来异步社区<Java入门经典(第7版)>一书中的第6章,第6.11节,作者:[美]Rogers Cadenhead(罗格斯卡登海德),更多章节内容可以访问云栖社区"异步 ...
[Java入门笔记] 面向对象编程基础（二）：方法详解
2019独角兽企业重金招聘Python工程师标准>>> 什么是方法? 简介在上一篇的blog中,我们知道了方法是类中的一个组成部分,是类或对象的行为特征的抽象. 无论是从语法和功能 ...
【极客学院每日1课】Java入门与常用技巧
2019独角兽企业重金招聘Python工程师标准>>> Java是Android开发者必学的基础编程语言.你的基础怎么样? 遥想当年,小乔还未出嫁,小编在大学里面,啃书本,听教授在课 ...
Java必备：java入门、java学习
2019独角兽企业重金招聘Python工程师标准>>> 版权声明:本文为北京尚学堂原创文章,未经允许不得转载. 1.Java入门 1-1．Java具有那些适合在Internet环境中 ...
Java入门学习笔记[狂神说Java]
写在前面: 本文根据B站狂神说Java 与菜鸟教程整理而来,仅供个人学习使用,如有侵权,请联系删除. 文章目录 IDEA使用 Java基础01:注释 Java基础02:数据类型 Java基础03:类 ...
一、Java入门和环境安装
@Author : By Runsen 本专栏是零基础学java的第一篇 Java入门和环境安装(一) 文章目录 1.Java入门 1.1 了解Java 1.2 选择Java版本 1.3 下载jdk ...

JAVA入门——lesson 7

Object 类详解

Object 类基本特性

toString 方法

==和 equals 方法

super 关键字

继承树追溯

封装(encapsulation)

封装的实现—使用访问控制符

封装的使用细节

多态(polymorphism)

对象的转型(casting)

抽象类

抽象方法和抽象类

接口 interface

接口的作用

如何定义和使用接口

接口中定义静态方法和默认方法(JDK8)

-JDK8 新特性_默认方法

静态方法和默认方法

接口的多继承

JAVA入门——lesson 7相关推荐

最新文章

热门文章