Java学习

Java面向对象相关知识点

Java面向对象的三大特征为：封装、继承和多态。

1. 封装

Java中的封装是指一个类把自己内部的实现细节进行隐藏，只暴露对外的接口（比如setter和getter方法）。封装又可以分为属性和方法的封装。把属性定义为private，使它们只能被setter和getter方法来进行设定和获取。或将方法定义为private，使他们只能在所在类内部被调用。下面是例子：

lang: java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class Person {
	private in id;
	private String name;
	Private Person person;

	public int getId(){
		return id;
	}

	public String getName(){
		return name;
	}

	public Person getPerson(){
		return person;
	}

	public void setId(int id){
		this.id = id;
	}

	public void setName(String name){
		this.name = name;
	}

	public void setPerson(Person person){
		this.person = person;
	}
}

在Person类中，定义了三个成员变量，分别为id name person，它们的访问修饰都是private私有的，通过setter和getter方法对这些变量进行设置以及取值。这么做的好处就是增强类的信息隐藏与模块化，可以防止该类的代码和数据被外部类定义的代码随机访问，减少耦合性，便于代码的理解和维护，也增加了代码的安全性。

2. 继承

Java中的继承是指在一个现有类的基础上再构建一个新类，其中现有类即父类，新类即子类。子类可以拥有父类的成员变量以及方法（但没有父类的构造器）。对于父类中的public和protected成员，子类可以访问、使用和重写。继承可以降低代码的重复性，但是会提高代码的耦合性。

父类：

lang: java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.company.test

public class Person{
	private int a = 1;
	private String name;
	private int age;

	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;
	}

	@Override
	public String toString() {
		return "Person ["name=" + name + ", age=" + age + "]";
	}
	
	
	public void say() {
		System.out.println("person say..");
	}
	
	//父类的私有方法
	private void show() {
		System.out.println("person show...");
	}
	
}

子类：

lang: java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.company.test

public class Student extends Person{
	@Override
	public void say(String content){
		super.say();
		System.out.println(content);
	}

	public static void main(String[] args){
		Student stu = new Student();
		//sut.a=2;//子类对象对父类的私有成员变量使用，报错。
		//stu.show();//子类对象调用父类的私有方法，报错。
		stu.say();
	}
}

继承可以实现代码的复用和扩展，通过对父类代码的复用，不需要重新声明父类中的成员变量，对父类的方法进行重写体现了扩展。

多态

多态即多种状态，就是说同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个借口，使用不同的实例而执行不同操作。

多态存在的三个必要条件

  • 继承
  • 重写
  • 父类引用指向子类对象
    比如：
    1
    Parent p = new Child();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
多态的好处：可以使程序由良好的扩展，并可以对所有类的对象进行通用处理。
例子：

lang: java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
public class Test{
	public static void main(String[] args){
		show(new Cat());	//以Cat对象调用show方法
		show(new Dog());	//以Dog对象调用show方法

		Animal a = new Cat();
		a.eat();		//此处调用的是Cat的eat
		Cat c = (Cat)a;
		c.work();
	}

	public static void show(Animal a){
		a.eat();
		if(a instanceof Cat){
			Cat c = (Cat)a;
			c.work();
		}else if (a instanceof Dog){
			Dog c = (Dog)a;
			c.work();
		}
	}
}

abstract class Animal{
	abstract void eat();
}

class Cat extends Animal{
	public void eat(){
		System.out.println("吃鱼");
	}
	public void work(){
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal{
	public void eat(){
		System.out.println("吃骨头");
	}
	public void work(){
		System.out.println("看家");
	}
}

执行后的输出结果为：
1
2
3
4
5
6
吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

多态的实现方式

方式一：重写

方式二：接口

    1. 生活中的接口最具代表性的就是插座，例如一个三接头的插座都能接在三孔插座中，因为这是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。
    1. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。

方式三：抽象类和抽象方法