Iava面向对象的一些简单知识点

1 概念

所谓的面向对象是一种编程思想，通过这种思想可以把生活中的复杂事情变得简单化，从原来的执行者变成了指挥者，面向对象是基于面向过程而言的。
我们经常说的面向对象的编程实现（OOP，Object Oriented Programming）。

2 特征

三大特征：
1、 封装性，把相关的数据封装成一个“类”组件
2、 继承性，是子类自动共享父类属性和方法，这是类之间的一种关
3、 多态，增强软件的灵活性和重用性

3 封装

3.1 封装概念

封装是指隐藏对象的属性和实现细节，仅仅对外提供公共的访问方式。
优点：
1、 提高安全性
2、 提高重用性

3.2private关键字

private关键字，是一个权限修饰符，用于修饰成员变量和成员函数，被私有化的成员只能在本类中访问。想要修改只能，对外提供公共的，get和set方法。
封装-private
总结:
1,通过private关键字,实现封装,提高资源的安全性(只能在本类里访问)
2,当属性被private后,需要提供public的getXxx()获取值/setXxx()设置值
3,当方法被private后,需要提供间接的访问方式

3.3构造方法

构造方法是一种特殊的方法，它是一个与类同名且返回值类型为同名类类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的创建或者对象的初始化。当类实例化一个对象时会自动调用构造方法。
构造方法和其他方法一样也可以重载。

普通方法语法：修饰符 返回值 方法名（[参数列表]）{方法体}
普通方法作用：主要用来完成指定的业务

构造方法语法：构造方法语法：修饰符 类名（[参数列表]）{方法体}
构造方法作用：主要用来完成对象的创建 和 对象的初始化

关于构造方法的总结:
1,作用: 可以用来new + 可以给成员变量赋值
2,语法: 修饰符 类名([参数列表]){方法体}
3,构造方法new时就被触发
4,构造方法会隐藏着一个无参的构造方法,但是当只提供含参构造方法时,无参构造就没有了
5,为了方便外界new,可以提供重载的构造方法
6,如果把构造方法private,那就只能在本类访问,外界无法new

3.4关于this关键字

总结：
1.this代表本类对象的一个引用,相当于this帮你创建了一个本类的对象
2.this可以调用同一个类里的所有资源(成员变量/方法/构造方法)
3,this使用的第一个场景是:用来区别同名的成员变量和局部变量,this调用的一定是成员变量
4,this使用的第二个场景是:用来在构造方法间互相调用
5,位置必须是第一条语句+不能形成类似于死循环的样子

4 继承

继承是面向对象最显著的一个特性。
继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并 能扩展新的能力。
Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增 加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类/超类/基类。

4.1 this和super的区别

1、 this代表本类对象的引用，super代表父类对象的引用。
2、 this用于区分局部变量和成员变量
3、 super用于区分本类变量和父类变量
4、 this.成员变量 this.成员方法() this(【参数】)代表调用本类内容
5、 super.成员变量 super.成员方法() super(【参数】)，代表调用父类内容
6、 this和super不可以同时出现在同一个构造方法里，他们两个只要出现都得放在第一行，同时出现的话，就会报错。

4.2 重写与重载的区别（Overload和Override的区别）

1、重载：是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同
2、重写：是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型
3、重写是父类与子类之间多态性的一种表现
4、重载是一类中多态性的一种表现

5 多态

5.1 概念

多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOP）的一个重要特征。
主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
好处是可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。
例如：水，在不同时刻可以有多种形态，包括水蒸气，冰，水。
Java怎么体现多态呢？狗有两种形态：狗和动物

class Animal
class Dog extends Animal

Dog d = new Dog();//狗是狗
Animal  a=new Dog();//狗是动物，创建了狗的对象，赋值给动物对象，这就是多态

5.2 特点

1、 多态的前提是继承
2、 要有方法的重写
3、 父类引用指向子类对象,如：Animal a = new Dog(); – 小到大，向上转型
4、 多态中，编译看左边，运行看右边

public class Test {
       public static void main(String[] args) {
              /*Animal  a = new Animal();
              a.eat();
              Dog d = new Dog();
              d.kanjia();
              d.eat();*/
//父类引用指向子类对象--把右面的小的，给了左面大的。相当于从小到大的过程，向上造型。
              Animal an = new Dog();
              an.eat();//只可以用父类的功能，这就统一了调用的标准
              //狗吃肉,由于eat()发生了重写，所以父类方法被覆盖掉了
       }
}
class Animal{
       public void eat(){
              System.out.println("大小通吃");
       }
}
class Dog extends Animal{
       public void kanjia(){
              System.out.println("狗可以看家");
       }
       public void eat(){
              System.out.println("狗吃肉");
       }
}

5.3 多态的好处

1，多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法。
2，提高了程序的扩展性和可维护性

public class Test{
       public static void main(String[] args) {
              //多态--父类引用指向子类对象
              Dog a2=new Dog();
              Cat a2 = new Cat();
              Animal2 a2 = new Dog();
              eat(a2);//传入的参数满足条件就可以，运行右面的功能
       }
//封装共性方法，不关心具体类型，只要传入的参数是子类就可以
       public static void eat(Animal2 a){
              a.eat();
       }
}

5.4 多态的使用

特点：
1、成员变量：使用的是父类的
2、成员方法：由于存在重写现象所以使用的是子类的
3、静态成员：随着对象而存在，谁调用的就返回谁的

public class Test {
       public static void main(String[] args) {
              Fu f = new Zi();//多态，只能用父类的。。。
              //多态的成员变量，就是父类的
              System.out.println(f.num);//10
              //成员方法，因为存在重写，所以是子类的
              f.study();//Zi..study()             
              //静态成员,谁调用就是谁的
              System.out.println(f.count);//10
              f.sleep();//Fu..sleep()
       }
}
class Fu{
       int num=10;
       static int count=10;
       public void study(){
              System.out.println("Fu..study()");
       }
       public static void sleep(){
              System.out.println("Fu..sleep()");
       }
}
class Zi extends Fu{
       int num=20;
       static int count=20;
       public void study(){
              System.out.println("Zi..study()");
       }
       public static void sleep(){
              System.out.println("Zi..sleep()");
       }
}