Java面向对象编程，类与对象总结

65 阅读 0 评论 43 点赞

我是靠谱客的博主无心钢笔，最近开发中收集的这篇文章主要介绍Java面向对象编程，类与对象总结，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

一 . 面向对象编程简介

1.面向对象三大特征
(1).封装性
(2).继承性
(3).多态性

2.面向对象名次扩展
(1).面向对象的分析 OOA
(2).面向对象的设计 OOD
(3).面向对象的编程 OOP

3.类与对象简介
(1).类是人类对实体抽象的映射，是人类大脑抽象思考的结果，进行抽象总结出来一个模版，这个模版被称为类，所谓的类就是指共性的概念。

(2).对象是实际存在的，现实世界中实际存在，指的是一个具体的，可以使用的食物。
1)类>>实例化>>对象
2)对象>>抽象>>类

(3).什么是对象？
对象是new运算符在堆内存当中开辟的内存空间称为对象。

(4).首先产生类，而后才能产生对象。对象的所有行为，一定在类中进行了完整的定义。
--------类中的组成
· 属性（变量，描述每个对象的具体特点）
· 方法（操作的行为）

(5)类的定义与使用

class 类名称{
属性1；
属性2；
属性n；.......

方法1（）{}
方法2（）{}
方法n（）{}....
}

例：一个Person的定义。

class Person{

    public String name;
    public int age;
    
       public Person(Sting name,int age)
     {
        this.name = name;
        this.age = age;
     }
  public String getPersonInfo(){
    return "姓名："+this.name+"，年龄："+this.age;
         
  }
 
}

有了类，就可以定义对象了。

定义对象的语法很简单，如下

类名称 对象名称 = new 类名称();

例：通过对象调用实例变量与实例方法

Person per = new Person("jack",26)
System.out.println(per.name);
System.out.println(per.age);

只要出现了关键字new，就开辟了内存。

(6).什么是引用？
引用是一个变量，只不过这个变量保存了另外一个java对象的内存地址，在栈中。

4.实例变量与局部变量
(1).java程序员想要访问堆内存当中的数据必须得经过引用的方式去访问堆内存当中的对象内部的实例变量。
(2).访问实例变量的语法格式
1)读取数据：引用.变量名 student.name;
2)修改数据：引用.变量名 = 值 student.age = 18;

Student student = new Student ;

(3).局部变量与成员变量的区别
1).上述student是引用是一个局部变量，Student则是一个对象，在堆内存中开辟空间。
2).局部变量在栈内存当中存储。
3)成员变量当中的实例变量在堆内存的java对象内部存储，实例变量是一个对象有一份，100个对象有100份。实例变量又被称为属性。
String是一个引用数据类型代表字符串类型，Address是一种引用数据类型代表家庭住址
方法调用的时候，该方法所需要的内存空间在栈内存当中分配，称为压栈，方法执行之后，该方法所属的内存空间释放，称为弹栈
栈中主要储存的是方法体当中的局部变量

对象内存分析代码

class Person{
    String name;
    int age;
}
public class Test(){
    public static void main(String[] args){
        Person per = new Person();
        per.name = "张三";
        per.name = "18";
    }
}

上述程序JVM图
方法的代码片段以及整个类的代码片段都会被储存到方法区当中，在类加载的时候代码片段会载入
//在程序执行过程中使用new运算符创建一个对象时，这个java对象储存在堆当中，对象内部有实例变量，所以实例变量储存在堆内存中

5.变量分类
—–局部变量【方法体中声明】
—-- 成员变量【方法体外声明】
(1) 实例变量前面修饰符没有static
(2) 静态变量前面修饰符必须要有static */
(3) 静态变量储存在方法区内存中
(4) 三块内存区变化最频繁的是栈内存，最先有数据的是方法区内存，垃圾回收器针对的是堆内存。

6.垃圾回收器【自动垃圾回收机制，GC机制】
(1).当堆内存中的对象成为垃圾数据的时候，会被垃圾回收器回收
(2).什么时候堆内存当中的java对象会变成垃圾呢？
答：没有更多的引用指向他的时候。。这个对象无法被访问因为这个对象只能通过引用的方式访问。

7.封装
先看一组代码：

class User{
    String name;
    int age;
}




public class UserTest{
    public static void main(String[] args) {
        User user = new User();
        user.name = "monkeyc";
        user.age = -100;
        System.out.println("用户名:"+user.name+"n"+"用户年龄:"+user.age);
    }

}

上述代码打印输出结果为：用户名：monkeyc
用户年龄：-100
对于当前程序来说：
（1）显然，用户年龄是不可能为负数的。
（2）User类中的age属性正在外部程序中可以随意访问，导致age属性的不安全。
（3）一个User对象表示一个用户，用户的年龄不可能为负数，程序当中年龄值为负数，程序运行的时候并没有报错，这是当前程序存在的缺陷。

这里就需要使用封装，为什么要封装，封装有什么好处？
1.封装之后，对外提供简单的操作入口，比如电视机就是一个很好的封装案例，电视机的实现远离非常复杂，但是对于使用电视机的人来说，只需要使用遥控器来操控电视机而不用去关心其内部的实现原理。
2.封装之后才能形成真正的"对象"，真正的"独立体"。
3.封装就意味着以后的程序可以重复使用，并且这个食物应该适应性比较强，在任何场合都可以使用。
4.封装之后，对于事物本身，提高了安全性。

封装的步骤：
1.所有属性私有化，使用private关键字进行修饰，private表示私有的，修饰的所有数据只能在本类中访问。
2.对外提供简单的操作入口，也就是说以后外部程序要访问age属性，必须通过这些简单的入口进行访问：
——对外提供两个公开的方法，分别是set和get方法
——想修改属性，调用set方法
——想读取属性，调用get方法
3.set方法的命名规范（以上述程序为例）：

 public void setAge(int a){ 
          age = a
  }

4.get方法的命名规范：

public int getAge(){
  return age;
}

setter and getter方法没有static关键字，有static关键字修饰的方法调用：类名.方法名（实参），没有static关键字修饰的方法调用引用.方法名（实参）。

8.对象属性的初始化方式？
(1).提供一些列的get和set方法（必须用public）
(2).通过提供合适的构造函数。
(3).静态代码块和实例代码块
对象的产生需要一下两步：
(1).为对象开辟内存
(2). 调用合适的构造函数（说明构造函数不止一个）
构造函数也可以发生重载。
9.this关键字
你怎么理解this的？
this表示当前对象的引用（内存的地址）
this的三种表示
静态代码块和实例代码块
静态代码块不能访问实例数据成员
静态代码块只会被初始化一次（static只会被打印一次）
对象的初始化顺序：静态代码块，实例化代码块，构造函数
内部类：1，实例内部类2，静态内部类，3，方法内部类4，匿名内部类
如何得到
---------------实例内部类
问题1:
实例内部类能不能定义static的数据成员？
答：能。必须是static final 原因是和对象初始化的顺序矛盾，应该先初始化static，但是在实例内部类中，class InnerClass先初始化，需要加final
final–>被final所修饰在编译期间确定的值。
问题2:实例内部类是否有额外的内存消耗？
实例内部类拥有外层内部类的this引用。OutClass.this
---------------静态内部类
问题3：
//静态内部类能否访问外部类的实例数据成员？答：可以，在构造内部类的时候，拿到外部类对象的引用，this.out.xxx
//---------------本地内部类（了解）
//---------------匿名内部类
//回调函数，pdf上5点
//继承：代码的重用 is-a关系
//1，class Student extends Person(Person:基类，父类，超类 Student：派生类，子类)
//派生类继承了基类，继承了什么东西？继承了除了构造函数之外的东西。
//派生类需要帮助基类构造 super(name,age)//去调用父类的构造函数，如果要用super调用父类的构造函数，必须放在子类函数的第一行
//super();//调用基类的构造函数 super.data;访问基类的属性super.func()调用基类的成员函数
//静态代码块只触发一次
//invokespecial 构造函数
//invokevirtual 普通方法虚函数
//invokestatic 静态方法
//overload 重载（函数名相同，参数列表不同，返回值不要求），override重写（函数名相同，参数列表相同，返回值相同）。
//多态：基类引用派生类的对象，并且基类和派生类有同名的覆盖（重写）方法。
//多态：把Student在方法区的地址传给了Person（700-300），发生了运行时的多态。
//所有的对象都放在堆上，但是Class对象放在方法区，保存着Class对象RTTI信息：runtime type information
//一个类型对应一张方法表，方法表在编译时产生，不一定非要拿到Student对象才能
//向下转型之前先进行一遍向上转型，Student student = （Student）person
//被final修饰的类叫做密封类不能被继承，被修饰的方法叫做密封方法，不能被重写。