JAVA入门——lesson 7

calm，think then do

已于 2022-02-27 20:02:29 修改

阅读量90

点赞数

文章标签： java 开发语言后端

于 2022-02-23 23:38:18 首次发布

本文链接：https://blog.csdn.net/m0_63476911/article/details/123083606

版权

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;
	@Override
	public 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;
	}
	@Override
	public 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，  但是此处向下转型为 StringBuffer
		StringBuffer 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() {
	}
}

calm，think then do

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA入门——lesson 7

Object 类详解Object 类基本特性Object 类是所有类的父类，所有的 Java 对象都拥有 Object 类的属性和方法。如果在类的声明中未使用 extends，则默认继承 Object 类。【示例】Object 类public class Person { ...}//等价于：public class Person extends Object { ...}toString 方法Object 类中定义有 public String toStrin
复制链接

扫一扫