Java面向对象的特征

java面向对象的思想特征

1. 封装
2. 继承
3. 多态

封装

1. 为什么要封装？（1）在我们的软件开发过程当中，我们定义的成员变量，或者成员方法，不想让外界访问，或想让外界间接的访问，我们就需要对成员变量或者成员方法进行封装；（2）在我们现实生活中我们也是有很多的事物是封装起来的，例如：电视机，我们普通人使用电视机只是需要看电视，电视能用即可，我们不需要了解他的内部构造，和执行流程等等；
2. 封装的好处
   （1）隐藏事物的实现细节
   （2）提高代码的复用性
   （3）提高了代码的安全性
3. 封装的原则
   （1）隐藏事物的属性
   （2）隐藏事物的实现细节
   （3）对外提供公关的访问方式

private关键字

1. private单词：私有的，隐私的

2. 可以修饰的内容
   （1）修饰成员变量
   （2）修饰成员方法
   （3）修饰构造方法
   （4）修饰内部类

3. 修饰之后的效果
   （1）被private修饰的成员，只能在本类访问。

get、set方法

1. 当属性被私有后，只能在本类调用，外界无法直接访问，所以需要提供公共的访问方式，让外界可以访问私有属性。对于当前类，就可以控制外界访问属性的方式（我让你怎么访问，你就只能怎么访问）
2. 一般提供get方法获取成员变量的值，提供set方法，设置成员属性的值
3. 代码示例

calss Demo{
	private String name;
	private int age;
//提供get、set方法
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getAge() {
		return age;
	}
}

继承

概述

1. 让类与类之间产生关系，子父类关系
2. extends关键字：扩展、增加、继承
3. 父类和子类
   （1）父类：被继承的类，超类、基类
   （2）子类：用于继承的类，派生类

继承的好处和弊端

1. 好处
   （1）提高代码的复用性
   （2）提高了代码的可维护性
   （3）是多态的前提

2. 弊端
   （1）提高了代码的耦合性

Java语言中继承的特点

1. Java语言支持单继承，不支持多继承，但支持多层继承。

多态

多态的概述

1. 多态：事物的多种状态（1）对象的多态性：① 同一个对象可能具有不同的名称。同一个对象指向不同的引用。②本质：同一个物体有不同的名称和描述。（2） 类型的多态性：①同一个类型，可能具有不同的子类实现。同一个类型的引用，有不同的对象实现

public class Demo {
	
	public static void main(String[] args) {
		//Cat c = new Cat();  正常情况
		Animal c = new Cat(); // 父类引用指向子类对象
		c.speak();
	}
	
}
// 定义个动物类
class Animal {
	
	public void speak() {
		System.out.println("动物叫");
	}
}
// 定义一个猫类继承动物类
class Cat extends Animal {
	
	@Override
	public void speak() {
		System.out.println("喵喵喵喵叫");
	}
}

2.多态的前提：（1）要有子类的继承（实现）关系；（2）有方法重写；（3）父类引用指向父类对象；

多态中 成员变量的访问特点

1. 编译看左边，运行看左边；
2. 编译的时候看【=】左边的父类引用是否有该变量定义，如果有则编译成功，如果没有编译失败；
3. 运行的时候看【=】左边的所属类型，真正如何给变量赋值，获取的是引用父类的赋值结果；

public class Demo_多态调用成员变量的特点 {
	public static void main(String[] args) {
		// 父类引用指向子类对象
		Animal animal = new Cat();
		System.out.println(animal.sum); // 运行结果20；
		// 编译看左边，运行看左边
	}
}
// 定义一个动物类
class Animal {
	// 声明一个变量
	int sum = 20;
}
// 定义个猫类继承于动物类
class Cat extends Animal {
	
	int sum = 50;
	String color = "black";
}

多态成员方法调用的特点

1. 编译看左边，运行看右边；
2. 编译的时候要看【=】左边类型中是否有该方法的定义，如果有则编译成功，如果没有则编译失败；
3. 运行的时候看【=】右边对象是如何实现该方法，最终以右边对象对这个方法重写后的结果；

多态中静态方法调用的特点

4. 编译看左边，运行看左边；
5. 编译时，要看【=】左边所属类型是否有该方法，如果有则编译成功，如果没有则编译失败；
6. 运行时，要看【=】左边所引用的类型对该方法如何实现的，最终运行结果要看引用类型对该方法的运行结果；

仅代表个人观点