面向对象的四大特征（非常重要）

面向对象四大特征：抽象，封装，继承，多态（非常重要）

1.抽象

定义：抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面,抽象只关注对象的哪些属性和行为,并不关注这此行为的细节是什么

1.1 研究事物的静态特征(属性)

1.2 研究事物的动态特征(方法/函数)

1.3 形成结果(类,class)

1.4 类和对象相互转变(new)

Student.java

public class Student { //1.1 研究事物的静态特征(属性) String name; int age; String cardNo; //1.2 研究事物的动态特征(方法/函数) /* * 吃饭 */ void eat(){ System.out.println("吃饭....."); } /* * 睡觉 */ void sleep(){ System.out.println("睡觉....."); } /* * 学习 */ void learn(){ System.out.println("学习....."); } public static void main(String[] args) { //声明一个学生类型的变量，指向内存当中学生的一个实例（1.3-1.4） Student s1 = new Student(); //类到对象 s1.name = "李四"; s1.age = 23; s1.cardNo = ""; System.out.println("姓名："+s1.name+",年龄："+s1.age+",身份证号:"+s1.cardNo); s1.eat(); s1.sleep(); } } 

2.封装

定义：通常认为封装是把数据和操作数据的方法绑定起来,对数据的访问只能通过已定义的接口.面向对象的本质就是将现实世界描绘成一系列完全自治,封闭的对象,可以说,封装就是隐藏一切可隐藏的东西,只向外界提供最简单的编程接口。封装给对象提供了隐藏内部特性和行为的能力，对象提供一些能这被其它对象访问的方法来改变它内部的数据。

2.1.提供构造方法(有了构造方法才能通过new去构建一个对象 1.构造方法必须和类名称一样2.构造方法不能有返回值)

空参构造系统默认存在，但是当你手动加入了有参构造，默认的空参构造将不再存在

 //空参构造 public Student(){ }; //有参构造 Student(String name){ this.name = name; System.out.println("初始化成功..."); } //有参构造 Student(String name,int age,String cardNo){ this.name = name; this.age = age; this.cardNo = cardNo; System.out.println("初始化成功..."); * //有了构造，在主方法中便可以创造对象 Student s1 = new Student(); 空参构造 Student s2 = new Student("王五"); //有参构造 Student s3 = new Student("赵六", 22, ""); //有参构造 } 

许许多多的构造方法形成了多态（重载），这个下边会讲到。

2.2 静态块(做的类的初始化的工作,执行在new之前)

静态块用于放创建对象前要做的一系列事情，比如说一个学生，首先要被孕育，然后出生…等等

static{ yunyu(); born(); } static void yunyu(){ System.out.println("孕育"); } static void born(){ System.out.println("出生"); } 

2.3 控制访问

具体情况具体分析

3.继承（关键字：extends）

目的：对父类和方法的复用

继承是从已有类得到继承信息创建新类的过程,继承让变化中的软件系统有了一定的延续性,同时继承也是封装程序中可变因素的重要手段.子类继承父类属性(静态特征)和方法(动态特征),继承必须遵循封装当中的控制访问

package com.oracle.object.extend; / * 动物类 * @author * */ public class Animal { String name; int age; int sex; void eat(){ System.out.println(name + "is eating......................."); } void sleep(){ System.out.println(name + "is sleeping......................."); } } 

BuRuAnimal.java

package com.oracle.object.extend; public class BuRuAnimal extends Animal{ public static void main(String[] args) { BuRuAnimal zhangSan = new BuRuAnimal(); zhangSan.age = 21; zhangSan.name = "张三"; zhangSan.sex = 0; System.out.println(zhangSan.name + "的年龄是" + zhangSan.age + "岁，性别是:" + (zhangSan.sex == 0 ? "男" : "女")); zhangSan.eat(); zhangSan.sleep(); } } 

PaXingAnimal.java

package com.oracle.object.extend; public class PaXingAnimal extends Animal{ public static void main(String[] args) { PaXingAnimal paXingAnimal = new PaXingAnimal(); paXingAnimal.age = 10; paXingAnimal.name = "鳄鱼"; paXingAnimal.sex = 0; System.out.println(paXingAnimal.name + "的年龄是" + paXingAnimal.age + "岁，性别为:" + paXingAnimal.sex); paXingAnimal.eat(); paXingAnimal.sleep(); } } 

Person.java

package com.oracle.object.extend; public class Person extends BuRuAnimal{ String job; String jobAdress; void speak(){ System.out.println("speak................"); } public static void main(String[] args) { Person liSi = new Person(); liSi.age = 21; liSi.name = "李四"; liSi.sex = 0; System.out.println(liSi.name + "的年龄是" + liSi.age + "岁，性别是:" + (liSi.sex == 0 ? "男" : "女")); liSi.eat(); liSi.sleep(); } } 

从上边的代码中可看出，子类中不要再定义属性和行为，直接继承父类，便有了父类的属性和行为，注意：访问修饰符决定了是否可继承

4.多态

多态性是指允许相同或不同子类型的对象对同一消息作出不同响应

4.1 重载:同一个动作作用在同一个对象上拥有不同的解释 overload

重载又称静态多态，编译时多态 

4.2 重写:同一个动作作用在不同的对象上拥有不同的解释 override

重写又称动态多态，运行时多态 

狭义的多态指重写

多态(重写)的机制:

4.2.1 声明一个父类型的引用指向具体子类型的实例

Person p = new Student(); 

4.2.2 运行时才能绑定

Person p = new Student(); 解释一下非运行时绑定： Student s = new Student(); 

4.2.3 运行时可变

p = new Teacher(); p = new Junren(); 

package com.tao.object.extend; / * 图形类 * @author 天外飞星 * */ public class Shape { public Shape(){ } public Shape(int a){ this.a = a; } public Shape(int a,int b){ this.a = a; this.b = b; } protected int a; protected int b; / * 计算周长 * @return */ public double countZhouChang(){ System.out.println("计算周长"); return 0; } / * 计算面积 * @return */ public double countArea(){ System.out.println("计算面积"); return 0; } } 

Triangle.java

package com.tao.object.extend; / * 正三角形 * @author * */ public class Triangle extends Shape { public Triangle(){ } public Triangle(int a){ this.a = a; } //重写 / * 计算当前三角形的面积 */ public double countArea(){ return Math.pow(3, 0.5) / 4 * Math.pow(a, 2); } //重写 @Override public double countZhouChang() { // TODO Auto-generated method stub return 3*a; } //以下是重载的体现，都是求area但是，方法各不相同，即同一个动作作用在同一个对象上拥有不同的解释 / * 计算边长为b的三角形的面积 */ public double countArea(int b){ return Math.pow(3, 0.5) / 4 * Math.pow(b, 2); } / * 计算底为c，并且高为h的三角形的面积 */ public double countArea(int c,int h){ return 0.5 * c * h; } / * 计算边长为d，并且此边长与斜边的夹角为e的的三角形的面积 */ public double countArea(int d,double e){ return d / 2 * Math.sin(e) * d; } public static void main(String[] args) { Triangle triangle = new Triangle(); triangle.a = 10; //triangle.countArea(); //triangle.countZhouChang(); /*double area = triangle.countArea(); System.out.println(area);*/ //double area = triangle.countArea(20); //System.out.println(area); //System.out.println(triangle.countArea(10, 8)); System.out.println(triangle.countArea(10, Math.PI / 3)); } } 

Rectangle .java

package com.tao.object.extend; public class Rectangle extends Shape{ public Rectangle(){ } public Rectangle(int a,int b){ this.a = a; this.b = b; } } //重写 @Override public double countZhouChang() { return 2*(a+b); } @Override public double countArea() { // TODO Auto-generated method stub return a*b; } } 

Ring.java

package com.tao.object.extend; public class Ring extends Shape{ public Ring(){ } public Ring(int r){ this.a = r; } @Override public double countZhouChang() { // TODO Auto-generated method stub return 2*Math.PI*a; } @Override public double countArea() { // TODO Auto-generated method stub return Math.PI*Math.pow(a,2); } } 

test.java

package com.tao.object.extend; public class test { public static void main(String[] args) { //声明一个父类型的引用指向具体子类型的实例 Shape shape=new Triangle(10); double zhouchang =shape.countZhouChang(); System.out.println("三角形周长："+zhouchang); double area=shape.countArea(); System.out.println("三角形面积："+area); //不用重新声明局部变量,体现了运行时可变 shape=new Rectangle(10,20); zhouchang=shape.countZhouChang(); area=shape.countArea(); System.out.println("矩形周长："+zhouchang); System.out.println("矩形面积："+area); //不用重新声明局部变量,体现了运行时可变 shape=new Ring(10); zhouchang=shape.countZhouChang(); area=shape.countArea(); System.out.println("圆周长："+zhouchang); System.out.println("圆面积："+area); } } 

关注公众号，随时学习最新内容，并与博主零距离交流！