java面向对象入门

参考教材：《Java核心技术 卷一》
参考视频：【狂神说Java】
参考网站： 菜鸟教程

一、类(class)和对象(object)

概述：类是构造对象的模板或蓝图。我们可以将类想象成制作小甜饼的模具，将对象想象为小甜饼。由类构造(construct)对象的过程称为创建类的实例。
1、对象：对象是类的一个实例，有状态和行为。例如：一只猫是一个对象，它的状态有：颜色，名字，品种；行为有：吃，睡，被rua等。
2、类：类是一个模板，它描述一类对象的行为和状态。
3、类与对象的创建：
类体=属性+方法
类的创建：

//学生类
public class Student{
	//属性
	String name;
	int age;
	//方法
	public void study(){
		System.out.println(this.name+"在学习");
	}
}

对象的实例化：

//在测试类中
public static void main(String args[]){
	//类实例化后会返回一个自己的对象!
	//student对象就是Student类的一个具体实例!
	Student student = new Student();
	student.name="George";
	student.age=30;
	System.out.println(student.name);
	System.out.println(student.age);
}

输出：

George
30

4、构造方法：每个类都有构造方法，如果没有显式地为类定义构造方法，java编译器将会为该类提供一个默认构造方法。在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

public class Person{
	String name;
	//实例化初始值
	//1、使用new关键字，本质实在调用构造器
	publlic Person(){
		this.name="yangle";
	}
	
	//有参构造：一旦定义了有参构造，无参就必须显示定义
	public Person(String name){
		this.name=name;
	}
}

二、封装

1、封装：是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。
2、封装的优点：
（1）良好的封装能够减少耦合。
（2）类内部的结构可以自由修改。
（3）可以对成员变量进行更精确的控制。
（4）隐藏信息，实现细节。
补充:乍听起来确实弯弯绕绕，总结起来就一句话：属性私有，get/set。
3、封装实例

//类   private：私有
public class Student{

	//属性私有
	private String name;//姓名
	private int age;//年龄
	private char sex;//性别
	
	//get获得这个数据
	public String getName(){
		return this.name;
	}
	//set给这个数据设置值
	public vois setName(String name){
		this.name=name;
	}
}

//测试类
public static void main(String[] args){
	Student s1 = new Student();
	s1.setName("Durant");
	System.out.println(s1.getName());
}

输出：

Durant

补充：
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

三、继承

1、继承的基本思想是，可以基于已有的类创建新的类。继承已存在的类就是复用（继承）这些类的方法，而且可以增加一些新的方法和字段，使新类能够适应新的情况。
2、extends的意思是“扩展”，子类是父类的扩展。
类的继承格式：

class 父类{
	......
}

class 子类 extends 父类{
	......
}

3、继承实例：

//公共父类
public class Person{

	private String name;
	private int age;
	
	public Student(String myName,int myAge){
		name=myName;
		age=myAge;
	}
	public void eat(){
		System.out.println(name+"is eating");
	}
	public void introduc(){
		System.out.println("I'm "+age+"years old");
	}
}

这个Person类就可以作为一个父类，然后学生类和工人类继承这个类之后，就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性（复用性主要是可以多次使用，不用再多次写同样的代码） 继承之后的代码：

//学生类
public class Student extends Person{
	public Student(String myName,int myAge){
		super(myName,myAge);
	}
}

//工人类
public class Worker extends Person{
	public Worker(String myName, int myAge){
		super(myName,myAge);
	}
}

4、继承的种类：

（图片来源于菜鸟教程）

5、super关键字注意点：
（1）super调用父类的构造方法，必须在构造方法的第一个。
（2）super只能出现在子类的方法或构造方法中。
（3）super和this不能同时调用构造方法。
6、重写（Override）
（1）重写是子类对父类的允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变。即外壳不变，核心重写！
（2）重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
（3）重写实例：
（a）我们首先创建一个父类B

public class B{

	public void test(){
		System.out.println("B=>test");
	}
}

（b）接下来我们创建一个B的子类A

public class A extends B{
	
	@Override
	public void test(){
		System.out.println("A=>test");
	}
}

（c）然后我们在测试类中执行一下

public static void main(String[] args){
	A a=new A();
	a.test();
	B b=new A();
	b.test();
}

运行结果如下：

A=>test
A=>test

四、多态

1、多态是同一个行为具有多个不同表现形式或形态的能力。
2、多态存在的三个必要条件
（1）继承
（2）重写
（3）父类引用指向子类对象：Parent p = new Child();
3、多态的示意图如下：

（图片来源于菜鸟教程）
示例代码：

class Shape {
    void draw() {}
}
 
class Circle extends Shape {
    void draw() {
        System.out.println("Circle.draw()");
    }
}
 
class Square extends Shape {
    void draw() {
        System.out.println("Square.draw()");
    }
}
 
class Triangle extends Shape {
    void draw() {
        System.out.println("Triangle.draw()");
    }
}

补充：当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
4、那么，我们为什么要掌握多态呢？
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。