- 一、面向对象是什么？
- 二、面向对象的三大特征
- 1.封装
- 2.继承
- 3.多态
- 三、面向对象的重点知识
- 1.方法的重写
- 2.四种修饰符权限
- 3.super关键字
- 4.包装类
- 总结
一、面向对象是什么？
面向对象是将功能封装成对象，强调的是功能的对象。于此一起的面向过程强调的是功能的行为。
二、面向对象的三大特征 1.封装面向对象的特征封装，我们在Java中把一个个复杂的方法写在方法中或者类中，让其暴露出简单的接口，对于用户使用更加友好，复用性更高。
public static int search(int[] nums, int target, int left, int right) {
int mid = (left + right) / 2;
int midVal = nums[mid];
if (left > right) {
return -1;
}
if (target > midVal) {
return search(nums, target, mid + 1, right);
} else if (target < midVal) {
return search(nums, target, left, mid - 1);
} else {
return mid;
}
}
我们调用search()方法就可以用二分法查找数据，但我们不用去知道其中的复杂实现。
2.继承面向对象的特征继承：就像我们儿子继承父亲一样，我们通过继承，可以让子类继承父类的大部分属性和方法(除去父类私有的)，这样我们就可以大大提高代码的复用性，减少代码的冗余。并且一个类有且只能有一个父类，也就是单继承。
注意：当我们使用继承时最好把无参构造方法也主动写上去，这样在之后新建子类对象时就不容易报错。(因为子类所有的构造器，都会默认访问父类的空参构造器，如果没有就会编译出错)
代码如下（示例）：
public class Shape {
int height = 4;
int width = 5;
public Shape() {
}
public Shape(int height, int width) {
this.height = height;
this.width = width;
}
}
public class Triangle extends Shape {
public void area(){
int areas;
areas = height*width/2;
System.out.println(areas);
}
}
3.多态
面向对象的特征多态：多态指的是不同对象对同一方法做出不同的反应。我们把不同的子类都当作父类来看待，不看他们直接的差异，写出通用的代码，以此来应对需求的不断变化。多态的前提的继承和重写。
注意：当我们把子类声明为父类时，我们只能使用父类中声明的方法，子类特有的方法不能进行调用。(如果非要使用可以用instanceof进行判断，然后进行强制类型转换)
代码如下（示例）：
public class Human {
String name;
int age;
String sex;
public Human(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public Human() {
}
public void eat(){
System.out.println("人吃饭");
}
public void read(){
System.out.println("人读书");
}
}
public class Man extends Human{
@Override
public void eat() {
System.out.println("男生吃饭");
}
@Override
public void read() {
System.out.println("男生读书");
}
}
public class Woman extends Human{
@Override
public void eat() {
System.out.println("女生吃饭");
}
@Override
public void read() {
System.out.println("女生读书");
}
}
public class TestHuman {
public static void main(String[] args) {
Human human = new Human();
Human man = new Man();
Human woman = new Woman();
human.eat();
human.read();
man.eat();
man.read();
woman.eat();
woman.read();
}
}
我们三个对象声明的都是human，调用的是同一个方法，当时执行的结果却各不相同，这就是多态。我们可以使用向上转型，也就是把子类声明为父类，当不能进行向下转型，不能把父类声明为子类。因为子类中有父类中没有的方法，如果我们转型成功的话，那么我们调用那些方法就会报错，因为父类中没有，相反向上转型就没有这个问题了。(也可以看成把大的范围转为小范围)
三、面向对象的重点知识 1.方法的重写
- 1.方法的从写：就是子类继承父类时把父类的方法进行覆盖和重置，写上自己的方法，在调用是执行子类的方法。
- 2.要求：方法的重写必须要和被重写的方法有相同的方法名称，参数列表，返回子类型。
- 3.要求：重写后的方法的范围权限必须要比之前的相同或者更大。
- 4.要求：重写后的方法的抛的异常范围也必须要比之前的相同或者更大。
代码如下（示例）：
package com.liu.test5;
public abstract class Animal {
String type;
int numLegs;
public void eat(){
System.out.println("吃东西");
}
public void walk(){
System.out.println("走路");
}
}
package com.liu.test5;
public class Spider extends Animal{
@Override
public void walk() {
System.out.println("蜘蛛爬墙");
}
@Override
public void eat() {
System.out.println("蜘蛛吃东西");
}
}
2.四种修饰符权限
对于class我们只能用public 或者default(不写)。一个class中可以有多个类，但只能有一个public类。private修饰的类，不能被继承，简称太监类。而且private修饰的方法和属性也不能被子类继承过去.
3.super关键字如果我们在子类和父类中都有属性name，我们在子类中需要调用父类中的name时，我们就需要使用super关键字来指定父类中的属性，这样使我们可以更好的区分子类和父类的方法和属性。并且super代表的不是父类对象，而是父类内存空间的标识。
public class Father {
String name;
int age;
public Father() {
}
public Father(String name, int age) {
this.name = name;
this.age = age;
}
}
public class Son extends Father{
String name;
int age;
public Son() {
}
public Son(String name, int age) {
this.name = name;
this.age = age;
}
public void show(){
System.out.println("父亲的名字="+super.name);
System.out.println("父亲的年龄="+super.age);
}
}
4.包装类
java有8种基本数据类型boolean,byte,short,int,long,char,float,double.对应的包装类型。基本数据类型包装成包装类的实例是装修，获得包装类的基本数据类型是拆箱。 Boolean,Byte,Short,Integer,Long,Character,Float,Double.包装类创建对象的方式跟其他类一样。包装类是为了使基本数据类型跟java的面向对象更加贴合，所以为其额外增加的。
包装类中的缓存机制
Integer num3 = 10;
Integer num4 = 10;
Integer num5 = new Integer(20);
Integer num6 = new Integer(20);
Integer num7 = 128;
Integer num8 = 128;
System.out.println((num3==num4) +" "+ num3.equals(num4));
System.out.println((num5==num6) +" "+ num5.equals(num6));
System.out.println((num7==num8) +" "+ num7.equals(num8));
Integer静态内部类被加载时，会创建-128到127的Integer对象，同时创建一个数组来缓存这些对象。num3和num4小于127,所以创建的是同一个Integer缓存对象，所以用==的结果为true。num5和num6使用new关键字指向两个不同的对象，结果为false。num7和num8，他们的值超过了127，所以同样创建了两个不同的对象，结果为false。
总结以上就是今天要讲的内容，本文仅仅简单介绍了java的面向对象，而面向对象为我们提供了一种很好的编程思想。
