面向对象三大特性

类和对象区别

什么是对象：在java的世界里，一切皆为对象；

也就是任何可以进行描述的某个具体的东西都可以成为对象； 例如：杯子，电脑，鼠标...

杯子可以组成集合：你的杯子，他的杯子...;电脑也是一样，这个集合我们叫做类

对象：一类事物中的具体化的个体(实例) 例如：我的杯子，我的电脑

类： 一类事物的抽象化描述 例如：杯子类， 电脑类

每个对象都可以进行描述，都拥有自身的特征和行为

例如：我的电脑

特征：颜色，尺寸，价格，品牌....------------名词，程序中叫属性

行为：运行，充电..... ------------动词，程序中叫方法

共性抽取：特征和行为都是对象的，但所有同类对象都应该具有相同的特征和行为；所以，在设计上，我们将特征和行为抽取到类中

面向对象编程设计：创建一个类，类中有属性和方法，实例化对象，通过对象调属性和方法

局部变量与成员变量的区别

主要从以下几点区分局部变量与成员变量

• 出现位置：

局部变量，出现在方法体中，方法参数中

成员变量，出现在类中，与成员方法同级

• 存储位置：

局部变量存储在栈区； 成员变量属于对象，存在堆区

• 作用域：

局部变量作用域在方法体中，出了方法体，则销毁

成员变量作用域，至少在当前类中

• 默认值：

局部变量没有默认值，必须先赋值，再使用

成员变量有默认值，String-null，int-0....和数组类似

• 重名问题：

重叠作用域下，重名变量，局部变量优先；作用域小的覆盖大的

封装性

理论描述

描述：封装方法，方法就是一种封装，在面向对象的封装性中，本质上也是讲方法的封装

封装性：在面向对象中，不要直接调属性，而是通过set/get方法进行封装

好处：结构更清晰，复用性更强，安全性更强

封装步骤

1.编写set/get方法，注意规范写法，set用于赋值，get用于取值

2.属性私有化

	public static void main(String[] args) throws Exception {
//实例化对象
		Student st = new Student();
//调用Set方法赋值
		st.setName("Kamisato");
		st.setAge(18);
//调用Get方法取值
		System.out.println(st.getName()+" "+st.getAge());
	}


//创建学生类
class Student{
//属性私有化
	private String name;
	private int age;
//创建Get Set 方法
	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;
	}
	
}

继承性

理论描述

生活中的继承： 子承父业，儿子继承了父亲的资源

程序中的继承：子类继承父类的属性和方法

如何设定继承关系？什么类是子类？什么类是父类？

两个类满足“is a”的关系，就有继承关系。

子类"is a" 父类 例如：猴子是动物，猴子是子类 动物是父类

找父类---父类有很多，怎么找直接父类

例如： 狗是动物，也是生物，也是物质

重合点(特征和行为接近)越多，越接近直接父类

重合点越少，越接近Object类（后面会分析-老祖宗类）

例如：狗-姓名，年龄，毛色； 吃，摇尾巴，睡； 动物也类似；所以，动物类是狗类的直接父类

继承特点

在继承中，没有多继承，但有多级继承

多继承：有多个父类； 多级继承：有父类，父类又有父类...

注意

• 私有的成员不能被继承

• 构造方法没有继承性

• 不同包的default权限，没有继承性

//案例：爷爷有1000万；爸爸有一辆跑车；儿子有一辆玩具车
class GrandFather{
	String name;
	public void haveMoney() {
		System.out.println(name+"拥有1000万");
	}
}
class Father extends GrandFather{ //多级继承
	public void haveCar() {
		System.out.println(name+"有一辆跑车");
	}
}
class Son extends Father/*,GrandFather*/{//没有多继承
	public void haveToy() {
		System.out.println(name+"有一辆玩具车");
	}
}
public class Test {
	public static void main(String[] args) {
		Father father = new Father();
		father.name = "父亲"; //调爷爷类的属性
		father.haveMoney();  //调爷爷类的方法
		father.haveCar();    //调自身的方法
		//father.haveToy();  //不能调子类的方法
		System.out.println("===============");
		
		Son son = new Son();
		son.name = "儿子";
		son.haveMoney();    //调爷爷类的方法
		son.haveCar();      //调父类的方法
		son.haveToy();      //调自身的方法
	}
}

重写

重载的概念：在同一个类中，方法名相同，参数个数或类型不同

重写的前提是继承；

在继承关系中，子类的方法和父类完全一致(包括返回值类型，方法名，参数类型)，权限大于或等于父类

重写非常重要，在后面的多态中经常用到

重写应用场景：当父类的方法不适用子类时，子类可重写父类的方法。

//案例：父亲非常绅士的吃饭；儿子狼吞虎咽的吃
class Father{
	public void eat() {
		System.out.println("父亲非常绅士的吃饭");
	}
}
class Son extends Father{
	@Override //重写注解，具有检测功能； 如果当前的方法不是重写方法，则报错
	public void eat() {
		System.out.println("儿子狼吞虎咽的吃饭");
	}
}
public class Test1 {
	public static void main(String[] args) {
		Son son = new Son();
		son.eat();
	}
}

supper与this

super表示父类对象；和this有点类似，只是this表示当前对象

在应用上也和this类似；super可以调用属性，方法，构造方法

super VS this

this调属性：调当前对象的属性；如果当前类没有，则根据继承性，调父类属性

this调方法：调当前对象的方法；如果当前类没有，则根据继承性，调父类方法

this调构造方法：调当前类的构造方法

super调属性：调父类的属性

super调方法：调父类的方法

super调构造方法：调父类的构造方法

public class caogao {
	public static void main(String[] args) throws Exception {
		//实例化对象时系统会默认调用自己的无参构造方法
		Son son = new Son();
		//子类用自己的属性
		son.id = 1;
		//子类用父类的属性
		son.name = "Ayaka";
		son.age = 18;
		//子类使用父类方法
		son.dad();
	}
} 


class Son extends Fathet{
	 int id;
	 
	public Son() {
		super();
		System.out.println("子类的构造方法");
	}
	
}


class Fathet{
	String name;
	int age;
	
	public void dad() {
		System.out.println("父类的方法");
	}
	
	public Fathet() {
		System.out.println("父类的构造方法");
	}
	
}

多态性

多态前提：必须要有继承或接口)

程序中的多态：将子类对象当成父类看待，这就是多态；换句话说，父类引用指向子类对象，即形成多态

例如：Animal an = new Dog(); //多态核心

多态应用：父类引用指向子类对象，即可调用父类的方法，不能调用子类独有的方法

class Animal{
	public void eat() {
		System.out.println("动物正在吃...");
	}
}
class Dog extends Animal{
	public void bark() {
		System.out.println("旺财正在汪汪汪...");
	}
}
public class Test1 {
	public static void main(String[] args) {
		Animal animal = new Dog();  //多态核心
		animal.eat();   //父类引用可调用父类方法
		//当成父类看待，则调不了子类方法
		//animal.bark();  //父类引用不能调子类独有方法
	}
}

多态重写的三种方式

直接引用多态

//直接引用多态的方式调用重写方法：
//案例：将猫当成宠物看待，可调用宠物的吃的方法；如果猫有不同吃的行为，则优先调用
class Pet{
	public void eat() {
		System.out.println("宠物正在吃东西...");
	}
}
class Cat extends Pet{
	@Override
	public void eat() {
		System.out.println("猫正在吃...");
	}
}
public class Test2 {
	public static void main(String[] args) {
		Pet pet = new Cat(); //父类引用指向子类对象，优先调子类重写方法
		pet.eat(); //子类有重写方法，优先调子类方法
	}
}

传参多态

面向对象设计原则：ocp原则-开闭原则
o-open:对外部扩展的类持开放状态-例如可扩展很多宠物类（扩展性）
c-close:对内部修改的代码持关闭状态-例如-主人喂养行为不要增加（维护性，灵活性）

多态的好处：使程序的扩展性，可维护性更强

//案例：主人喂养宠物，猫，狗都是宠物，都有各自吃的行为
//分析：类-宠物类(父)，猫类(子)，狗类（子），主人类(第三方类)； 方法-吃，喂养
//两个宠物，就需要写两个喂养的方法；后面扩展更多宠物，则继续增加喂养方法


class Pet{  //宠物类
	public void eat() { //吃
		System.out.println("宠物正在吃...");
	}
}
class Dog extends Pet{
	@Override
	public void eat() { //重写吃
		System.out.println("旺财正在吃...");
	}
}
class Cat extends Pet{
	@Override
	public void eat() { //重写吃
		System.out.println("加菲猫正在吃...");
	}
}
class Master{  //主人类
	//传参实现的多态
	public void feed(Pet pet) {//Pet pet = new Dog(); 多态
		pet.eat(); //谁传给我，就调谁的 （不要看谁调的，要看谁传的）
	}
}
public class Test1 {
	public static void main(String[] args) {
		Master master = new Master();
		master.feed(new Dog());  //1.主人喂养狗
		master.feed(new Cat());  //2.主人喂养猫
	}
}

返回值多态

//返回值多态：调用方法返回子类对象，由父类引用接收；构成返回值多态
//案例：主人购买宠物；根据标识购买不同宠物：1.买鸟 2.买狗
//分析：类-主人类（第三方类）；宠物类（父），鸟，狗（子） 方法：购买
class Pet{	
	public void eat() {
		System.out.println("宠物在吃东西");
	}
}
class Bird extends Pet{
	@Override
	public void eat() {
		System.out.println("鸟正在吃东西");
	}
}
class Dog extends Pet{
	@Override
	public void eat() {
		System.out.println("狗正在吃东西");
	}
}
class Master{
	public Pet bug(int type) {
		if(type==1) {
			return new Bird();
		}else if(type==2) {
			return new Dog();
		}else {
			return null;
		}
	}
}
public class Test1 {
	public static void main(String[] args) {
		Master master = new Master();
		Pet pet = master.bug(1); //返回子类对象；用父类Pet接收，形成多态
		pet.eat(); //调子类重写方法
	}
}

抽象类

某些类具有某种方法，但不能具体实现，这样的方法叫抽象方法；所在的类就是抽象类。

例如：动物类（抽象类）----叫（抽象方法）

这样的抽象类我们无法具体化(不能实例化对象)，可以交给子类具体化以及具体实现。

好处：

更自然地使用多态； 抽象方法可以当成模板来使用

抽象类细节说明：
1.抽象类能否具体化                不能
2.抽象类能否有构造方法         因为子类构造方法可以调：super()
3.有抽象方法的类一定是抽象类吗？     是的
4.抽象类是否必须有抽象方法？        可以没有抽象方法
5.抽象类是否可以有非抽象方法？     可以有
6.父类为抽象类，子类是否必须要重写抽象方法？  不是必须的，也可以将子类变为抽象类

多态重写的三种方式中书写的三种案例都可以将Pet类变成抽象类

例如

abstract class Pet{  //宠物类
	public abstract void eat();
}
class Dog extends Pet{
	@Override
	public void eat() { //重写吃
		System.out.println("旺财正在吃...");
	}
}
class Cat extends Pet{
	@Override
	public void eat() { //重写吃
		System.out.println("加菲猫正在吃...");
	}
}
class Master{  //主人类
	//传参实现的多态
	public void feed(Pet pet) {//Pet pet = new Dog(); 多态
		pet.eat(); //谁传给我，就调谁的 （不要看谁调的，要看谁传的）
	}
}
public class caogao {
	public static void main(String[] args) {
		Master master = new Master();
		master.feed(new Dog());  //1.主人喂养狗
		master.feed(new Cat());  //2.主人喂养猫
	}
}