Java学习笔记(二)--面对对象

Java学习笔记(二)

类（引用数据类型）

类的类型有两种方式：
1）人家定义好的类，我们可以通过导包的方式，将对应的类引入到当前程序中进行使用。、
import java.util.Scanner; import java.util.Random;
import java.util.*;
2）如果业务上需要使用自定义的信息，我们可以自己来定义一个类。
如：

// 定义一个类
public class 类名 {
// 定义字段 field
int a = 1;

// 定义方法（无返回值）
public void getName(){
}
// 定义方法（有返回值）
public String getName(){
return “”;
}
}

面向对象

// 面向对象中三大特性的主要目的：
// 封装：把对象的属性和方法的实现细节隐藏起来，可以对外提供一些公共方法进行访问。public 共有的， private 私有的
// 继承：希望子类拥有父类中所有能用的功能，然后还可以在子类中进行增强。当需要注意，Java 只有单继承。
// 多态：结合继承和方法的重写来提高代码的复用性和功能增强（扩展性）。

继承

在父类中：

// 继承的使用注意点：
	// 宗旨：子类，永远比父类牛。子类的功能更加丰富，子类在开发中，主要是用来增强功能的。
	// 1. 在 Java 开发中，类只支持单继承，不支持多继承。只能是有一个直接的父类。
	// 		A extends B 对的，A extends B,C,D 错的
	// 2. 多个类可以同时继承一个父类。
	//      A extends C， B extends C 对的
	// 3. 也支持多层继承，子类的父类还可以去继承另一个父类
	//      A extends B，B extends C， C extends D
	// 4. 子类和父类其实是一个相对的概念，一个类可以是某个类的父类，也可以是另外一个类的子类。

public class Employee {

	// 员工姓名
	private String name;
	
	// 定义一个变量
	int money = 2000;

	// get 和 set
	public String getName() {
		return name;
	}

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

	// 员工工作
	public void working() {
		System.out.println("每天都愉快地工作...");
	}
	
	public void sayHello(){
		System.out.println("我是一个超级好员工...");
	};
	在子类中：
// 我们使用 extends 关键字，来继承指定的 Employee 父类（超类）
public class JavaCoder extends Employee {
	
	int money = 10000;

	// @Override 主要是用来声明，当前方法是从父类中重写（重新写了一遍，照搬父类的）出来的
	@Override
	public void working() {
		
		// super 关键字，代表是父类的实例，主要是用来调用父类中的东西。
		// super.working();
		
		// 要使用父类中的同名变量
		System.out.println("父类中的 money：" + super.money);
		
		// 要使用子类中的同名变量
		System.out.println("子类中的 money：" + this.money);
		
		// 我在子类中，新加入的一个功能
		System.out.println("我是员工，属于 Java 开发小组，我会写 Java 代码...");
	}
创建一个新类test来测试：
@Test
	public void test(){
		
		// 创建 JavaCoder 实例
		JavaCoder java = new JavaCoder();
		java.working();
		// 就算没有重写父类的方法，也可以直接使用父类中方法
		// 如果子类重写了，其实也就是在原来的基础之上增强了
		java.sayHello();
		
		System.out.println("---------- 超完美的分割线 -----------");
		
		// 初始化子类之后，将实例赋值给父类类型变量
		Employee e = new JavaCoder();
		// 再调用方法
		e.working(); 
	}

封装

实现Java封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private），例如：

public class Person {
    private String name;
    private int age;
}

这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

public class Person{
    private String name;
    private int age;
​
    public int getAge(){
      return age;
    }
​
    public String getName(){
      return name;
    }
​
    public void setAge(int age){
      this.age = age;
    }
​
    public void setName(String name){
      this.name = name;
    }
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

多态

// 多态：多个状态
// 多态的特点：
	// 1）最终的多态体现在父类引用变量可以指向子类对象。
	// Person person = new Son();
	// 2）多态的前提是必须要有子父类关系或者类实现接口关系，否则不能完成多态建设。
	// 3）在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。

// 语法格式：
	// 父类类型 变量名 = new 子类类型();

// 1. 普通类型多态定义
	// 2. 抽象类多态定义
	// 3. 接口多态定义

// 同一个父类的方法可以给多个不同的子类进行重写，在调用方法的时候，都是调用各个不同子类中重写后的方法。

接口

	@Test
	public void test() throws Exception{
		/*
		Hello hello = new HelloImpl();
		hello.sayHello();
		hello.saySomething();
		
		
		Hello hello2 = new HelloImpl2();
		hello2.sayHello();
		hello2.saySomething();
		 */
		
		ChildImpl child = new ChildImpl();
		//child.getMoney();
		//child.getMoney2();
		
		int total = child.getTotalMoney(2, 200);
		System.out.println(total);
	}

// 1. 接口也是一种类型
// 与抽象类，几乎一样。但它比抽象类，还要抽象。
// 接口是功能的集合，也可以看做是一种数据类型。

// 2. 接口的使用方式
// 使用接口，需要提供一个接口类，使用 interface 修饰。
// 另外还需要提供一个实现类，用于实现接口。使用 implements 关键字实现指定的接口。
// 接口中的方法，只提供方法声明，不提供方法的实现细节。为了安全，不向外提供方法实现，只需要返回对应结果即可。

// 3. 接口的好处
// 因为方法也可以认为是功能，功能的定义可以与实现进行分离。
// 当功能的细节，需要进行更改的时候，我们不需要去动方法的定义。我们只需要去对应的实现中进行更新即可，
// 好处就是，方法的调用者不需要针对功能改变而改变方法的调用
// 4. 接口的初始化
// 因为接口中没有实现，new 了之后得不到需要的实现细节，所以不能 new。
// 我们需要初始化实现类，然后可以使用接口类型的变量接收实例。

// 5. 接口的多个实现类
// 在前面，我们学习的继承，只能够是单继承，不能是多继承。
// 使用了接口，其实可以在一定情况下，弥补了不能多继承的缺点。
// 【可能出现的问题】在实现的时候，我们需要同时实现所有接口中必须要重写的方法。
// 而且，要花很多精力来处理好不同接口之间方法的关系，和详细逻辑，调用的时候容易出现混乱。
// 【解决方案】尽量在继承父接口后的子类中，使用额外的方法体来处理整个需要获取的数据。做到整合使用。
// 步骤如下：
// 1. 需要重写方法，没有关系，直接重写即可。
// 2. 最好添加一些容易识别的方法，共调用者使用，获取对应的数据即可。

构造器（构造函数、构造方法）

@Test
	public void test(){
		
		// 无参构造器
		User user = new User();
		// 调用 set 方法设置值
		user.setName("翠花");
		user.setAge(18);
		
		// 有参构造器
		User user2 = new User("春花", 21);
		System.out.println(user2.getName() + "---" + user2.getAge());
	}

每一个类都有一个隐藏的无参构造器，主要是用来初始类的实例的。
配合 new 关键字来使用，当开始 new 的时候，构造器就会被执行，会在堆内存中开辟一个空间存储对象实例。
如果我们直接使用无参的构造器，所得到的实例是空的，没有任何值的。
如果一个类中，出现一个有参构造器，则会默认覆盖无参构造器。
如果还要用到无参构造器，需要我们手动添加出来才行。
构造器的总结：

1. 构造器没有返回值，也不用去添加。
2. 主要用来构造对象，创建完对象之后，就结束了，只执行一次。
3. 构造器的名字，必须要和类名一致。
4. 一个类中可以存在多个构造器，主要是以重载的形式存在。
5. 可以使用 private 进行修饰，但修饰之后其他地方不能调用了。

重写(Override)与重载(Overload)

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

抽象类

1：

public abstract class Employee {
	
	// 声明一个抽象方法，需要使用 abstract 关键字来修饰
	public abstract void working();

}

2：

public class JavaCoder extends Employee {

	@Override
	public void working() {
		System.out.println("我是一个令 PHP 项目的 Java 工程师...");
	}
}

3：

public class PHPCoder extends Employee {

	@Override
	public void working() {
		System.out.println("我是一个 PHP 开发工程师，好羡慕 Java 工程师啊...");
	}

}

4：

public class Demo {
	@Test
	public void test(){
		PHPCoder p = new PHPCoder();
		p.working();
		
		JavaCoder j = new JavaCoder();
		j.working();
	}

}

抽象：主要是在观察事物的时候，将发现的共有属性，向上抽取。
抽象类的特点

1. 抽象类和抽象方法都需要使用 abstract 关键来修饰
2. 抽象方法只能在抽象类中书写。
3. 抽象类不能单独创建，因为单独创建没有任何用，需要使用子类来继承并且实现方法。
4. 创建好子类，必须要将抽象类中的方法进行实现，然后才能够进行实例化使用。

接口和抽象类的区别

接口和抽象类的区别
相同点：
1）都是跟继承有联系的，位于继承的顶端，主要是给其他类实现或者继承。
2）都不能够进行实例化。抽象类的子类来实例化，接口的实现类来实例化。
3）都可以包含抽象方法，子类在使用的时候，都需要去重写（覆盖）这些声明出来的方法。
不同点：
）抽象类为部分方法提供实现，避免子类重复去实现这些方法，可以提高代码的重用性。
接口只能是包含抽象方法的定义。
2）一个类可以继承一个父类（抽象类），但我们可以实现多个接口，接口可以用来弥补 Java 的单继承缺点。
3）抽象类主要是指一个事物中应该要有的内容，比如是 is…a 关系。
4）接口主要是指一个事物中额外的内容，比如是 like…a 关系。
如何选择使用：
1）通过实际工作的效率上分析，要多用接口，少用抽象类。
2）当需要定义子类的行为，还要为子类提供共有性能的时候，才选用抽象类。