Java05-面向对象的对象和类及三大特征

1 面向对象

1.1 概念

面向对象编程(OOP，Object Oriented Programming),所谓的面向对象是一种编程思想，通过这种思想可以把生活中的复杂事情变得简单化，从原来的执行者变成了指挥者，面向对象是基于面向过程而言的.

面向过程:面向过程强调的是过程步骤

面向过程就是分析出实现需求所需要的步骤，通过函数一步一步实现这些步骤

面向对象:面向对象强调行为

面向对象是把整个需求按照特点、功能划分，将这些存在共性的部分封装成对象，创建了对象不是为了完成某一个步骤，而是描述某个事物在解决问题的步骤中的行为

例如:
1、 饿了，去平台点餐，这个动作就是面向对象。你没有去市场买菜洗菜做饭。。。只要有app就可以了。
2、 衣服脏了，直接甩给女票去处理等着穿干净的就可以了。你没有关注中间的过程。。只要找好对象就可以了

1.2 三大特征

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

1.2.1 封装

封装是指隐藏对象的属性和实现细节，仅仅对外提供公共的访问方式

封装的好处

1、 提高安全性
2、 提高重用性

private关键字

是一个权限修饰符，用于修饰成员变量和成员函数，被私有化的成员只能在本类中访问。
想要修改只能，对外提供公共的，get和set方法

public class Student {
       //把属性隐藏起来
       private String name;
       //提供公共的访问方法
       //设置公共的赋值方法
       public void setName(String n){
              name=n;
       }      
       //设置公共的取值方法
       public String getName(){
              return name;
       }         
}

1.2.2 继承

概念

1.继承是面向对象最显著的一个特性。
2.继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力
3.Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类/超类/基类
4.这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用
5.提高复用性：只要继承父类，就能有一样的功能

格式

通过 extends 关键字可以申明一个类是从另外一个类继承而来

class 父类 {
}
class 子类 extends 父类 {
}

继承类型

继承的特性(is-a)

• 子类拥有父类非 private 的属性、方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

super关键字

1、 通过super关键字可以使用父类的内容
2、 super代表父类的一个引用对象
3、 如果用，必须出现在调用位置的第一行

方法重写

1、 继承后，子类就拥有了父类的功能
2、 那么在子类中，可以添加子类特有的功能也可以修改父类的原有功能
3、 子类中方法签名与父类完全一样(包括方法的返回值，方法名和参数列表，完全一致)时，会发生覆盖/复写操作，相当于修改功能
注意：
1、父类中的私有方法不能被重写
2、子类重写父类方法时，修饰符要大于等于父类修饰符的权限

继承中构造方法的使用

1、 子类创建对象时，默认会去访问父类的无参构造方法
2、 在构造方法的第一行，都有一条默认的语句：super();
3、 父类没有无参构造时，可以用super调用父类的其他构造

1.2.3 多态

• 多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOP）的一个重要特征。
• 主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
• 好处是可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

特点

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

入门案例

public class p {
       public static void main(String[] args) {          
//父类引用指向子类对象--把右面的小的，给了左面大的。相当于从小到大的过程，向上造型。
              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("狗吃肉");
       }
}

好处

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

多态的使用

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

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

class Fu2{
       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 Zi2 extends Fu2{
       int num=20;
       static int count=20;
       public void study(){
              System.out.println("Zi..study()");
       }
       public static void sleep(){
              System.out.println("Zi..sleep()");
       }
}

1.3 类和对象

1.3.1 类

类是一个模板，它描述一类对象的行为和状态
那怎么通过java语言描述事物呢？
通过类来描述事物，把事物的属性当做成员变量，把行为当做成员方法

1、 Java语言最基本单位就是类，类似于类型。
2、 类是一类事物的抽象。
3、 可以理解为模板或者设计图纸。

1.3.2 对象

对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等

每个对象具有三个特点：对象的状态，对象的行为和对象的标识。
1、 对象的状态用来描述对象的基本特征。
2、 对象的行为用来描述对象的功能。
3、 对象的标识是指对象在内存中都有一个唯一的地址用来和其他对象区分开来。
4、 类是一类事物的抽象，对象是具体的实现。

1.3.3 类和对象的创建和使用

• 通过class关键字创建类，通过new关键字创建对象

public class Test1 {
       public static void main(String[] args) {
              //p是引用对象，持有了对于Person对象的地址值的引用
              //此时的p，含有属性，但都是默认值
              Person p = new Person();
              //设置属性值
              p.name="lisi";
              p.age=20;
        //调用方法
              p.eat();
              p.sleep();             
       }
} 
class Person{
       //属性--成员变量
       String name;
       int age;      
       //行为--方法
       void eat(){
              System.out.println("吃饭");
       }      
       void sleep(){
              System.out.println("睡觉");
       }
}

1.3.4 对象在内存中的存储

绿色:表示线程共享
橙色:表示线程私有

• **方法区:**运行时常量池,类结构信息,静态变量,构造函数信息,即时编译器编译后的代码
• **堆:**存放对象实例或数组
• **虚拟机栈:**栈帧-局部变量表,操作数栈,动态链接,方法出口
• **本地方法栈:**Native方法
• **程序计数器:**虚拟机字节码指定的地址或undefined

1、 一般来讲局部变量存在栈中，方法执行完毕内存就被释放
2、 对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放
3、 每个堆内存的元素都有地址值
4、 对象中的属性都是有默认值的

1.3.5 单一对象内存图

1、 在栈内存中，创建一个引用变量p，持有对象的地址值
2、 在堆内存中，创建Person对象，并且开辟变量的空间，完成初始化
3、 给堆内存中的元素，分配一个唯一标志，地址值。交给p去保存。
4、 p.name=”lisi”;p.age=20;就去堆内存中找唯一的地址值，找到Person对象，并对其属性进行修改赋值。
5、 p.eat();就去堆内存中找唯一的地址值，找到Person对象，执行Person对象的方法。

1.3.6 多对象内存图

1、 变量p和变量p1不是一片空间，p1需要开辟新的空间
2、 Person p1=new Person，这时只要有new，就会新开辟空间在堆内存中存入对象

1.3.7 创建对象的流程

Person p = new Person();

1.  把Person.class文件加载进内存
   

2.  在栈内存中，开辟空间，存放变量p
   

3.  在堆内存中，开辟空间，存放Person对象
   

4.  对成员变量进行默认的初始化
   

5.  对成员变量进行显示初始化
   

6.  执行构造方法（如果有构造代码块，就先执行构造代码块再执行构造方法）
   

7.  堆内存完成
   

8.  把堆内存的地址值赋值给变量p ，p就是一个引用变量，引用了Person对象的地址值