java中如何去理解 类，对象（实例），方法，类变量，对象（实例）变量的区别与联系

创建一个类时就创建了一种新的数据类型，使用这种类型来声明该类型的对象。

然而要获得一个类的对象需要两步， 第一， 必须声明该类类型的一个变量，这个变量没有定义一个对象，它只是一个能够引用对象的简单变量。
第二，该声明要创建一个对象的实际物理拷贝，并把对于该对象的引用赋给该变量，通过使用new运算符为对象动态分配内存空间。

例如：Box mybox=new Box();这样是将两步组合到一起了。
可以将该语句分两步写成下面的形式：
Box mybox; //声明mybox，把它作为对于Box类型的对象引用，执行后mybox的值为null，表示没有引用对象
mybox=new Box(); //创建了一个实际的对象，并把它的引用赋给mybox，可以将mybox作为Box的对象来使用。实际上mybox仅仅保存实际的Box对象的内存地址
new运算符
new运算符动态的为一个对象分配地址。格式如下：class-var=new classname();
其中class-var是所创建类类型的变量 classname是被实例化的类的名字 后面的括号指定了类的构造函数，定义当创建一个类的对象时将发生什么
构造函数是所有类的重要组成部分，大多数类在他们自己的内部显式地定义构造函数。如果一个类没有显式的定义它的构造函数，那么java将自动提供一个默认的构造函数

类和对象的区别
1、类是对某一类事物的描述，是抽象的；
而对象是一个实实在在的个体，是类的一个实例。比如：“人”是一个类，而“教师”则是“人”的一个实例。比如：“老师”是类。“你的老师”就是对象。
2、对象是函数、变量的集合体；
而类是一组函数和变量的集合体，
即类是一组具有相同属性的对象集合体。
3、类的数据值是共享的，一个实例能访问它所属类的类数据值；
而实例数据属于单个对象，除共享了所在类中的数据外，
不同对象还会有不同的数据值。
4、先有类，才有类的实例——对象。
应用在：当你在创建某个类的实例（对象）之前，这个类必须被定义。
5、实例方法和类方法的区别在于：
实例方法属于单个对象，类方法属于类。
类创建一种新的数据类型，该类型被用来创建对象。也就是，类创建了一个逻辑的框架，该框架定义了它的成员之间的关系。当你声明类的对象时，你正在创造类的实例。因此，类是一个逻辑构造，对象有物理的真实性(也就是对象占用内存空间)
方法、函数、消息、变量、属性之间的关系。
1、方法就是对象的行为，即函数；
2、消息也是调用某个对象的函数，即方法。
3、变量就是对象的状态，即属性。
被继承的类叫超类（superclass ），继承超类的类叫子类（subclass ）。
子类是超类的一个专门用途的版本，它继承了超类定义的所有实例变量和方法，并且为它自己增添了独特的元素。
在继承关系当中，一个子类能够从它的超类当中继承所有的东西，子类能够吸收现有类的数据和方法。
通过继承，子类不仅仅展示了其超类的行为和特征，而且还展示了特定于自身的行为和特征。

java中类变量、类方法、实例变量、实例方法

在理解类变量、类方法之前先看一段代码：

class Person
{
    int age ;
    String name;
    static int totalFee;
    public void showName()
    {
        System.out.print(this.name);
    }
    public static void showTotalFee()
    {
        System.out.print(totalFee);
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

在Person类中定义了3个变量，有2个变量是直接类型+变量名，而第3个变量的类型前加了static这个关键字。
类变量也叫静态变量，也就是在变量前加了static 的变量；
类变量的定义：访问修饰符 static 数据类型 变量名
实例变量也叫对象变量，即没加static 的变量；
那么他们的区别究竟是什么呢？
类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属
对象私有，某一个对象将其值改变，不影响其他对象；
还有，类变量和实例变量都属全局变量

在Person类中还定义了2个方法，区别是第2个方法也是多了个static关键字。
对于这个方法即类方法，类方法是属于与类相关的，公共的方法。
实例方法属于每个对象个体的方法。
类方法的定义：访问修饰符 static 返回数据类型 方法名（）{}

楼主诸位说的都太复杂，我们应该从编程的发展史来谈面向对象的出现。当软件还非常简单的时候，我们只需要面向过程编程：定义函数
函数一
函数二
函数三
函数四

定义数据
数据一
数据二
数据三
数据四

最后
各种函数，数据的操作。
当软件发展起来后，我们的软件变得越来越大，代码量越来越多，复杂度远超Hello World的时候，我们的编写就有麻烦了：

函数和数据会定义得非常多，面临两个问题。首先是命名冲突，英文单词也就那么几个，可能写着写着取名时就没合适的短词用了，为了避免冲突，只能把函数名取得越来越长。然后是代码重复，比如你做一个计算器程序，你的函数就要确保处理的是合理的数据，这样最起码加减乘除四个函数里，你就都要写对参数进行检测的代码，写四遍或者复制粘贴四遍不会很烦，但多了你就痛苦了，而且因为这些检测代码是跟你的加减乘除函数的本意是无关的，却一定要写在那里，使代码变得不好阅读，意图模糊。

就算一个网络小说的作者，他每次写新章节时也不大可能直接打开包含着前面几百章文字的文档接着写。更正常的做法是新建一个文档，写新的一章，为的是减小复杂性，减少干扰。更何况代码那么复杂那么容易出错的东西。随着软件业的发展，解决办法就要出来了。代码重复，我们可以用函数里面调用函数的方法，比如把检测代码抽出来成一个独立函数，然后加减乘除四个函数运行时只要调用一下检测函数对参数进行检查就可以了。分布在四个函数里的重复代码变成了一个函数，是不是好维护多了。命名冲突，我们就把这一堆函数们进行分类吧。比如没有分类时候，我们取名只能取名：检测
整数加
整数减
整数乘
整数除
复数加
复数减
复数乘
复数除
小数加
…
进行归类后整数 {
检测
加
减
乘
除
}
复数 {
检测
加
减
乘
除
}
小数 {
检测
加
减
乘
除
}
分数 {
检测
加
减
乘
除
}
是不是一种叫做类的概念就呼之欲出了，这样我们打开一个整数类代码文件，里面就是简简单单的加减乘除四个函数，简单清晰而不会跟外面的其他加减乘除函数命名冲突。当然，进行归类后，又有各种的问题和解决办法了，比如四个类中的检测也是应该提取出来的，所以简单的起因最终发展出什么继承衍生之类挺复杂的一套编程模式。然后学术界那帮人就又乱起什么高大上的名字了，所谓面向对象程序设计去*大学里那帮孩子。就算未来出来一个什么新的面向XX编程，我们也不用多想为什么会出现，肯定是为了解决麻烦而已。2016年5月23日更新：上面进行归类后，代码其实还是不好维护的，然后我们就继续提取为：数 {
检测
加
减
乘
除
}
整数 {
沿用上面数的设计
}
小数 {
沿用上面数的设计
}
所谓继承，就是数这个类的整体设计，沿用给整数，分数小数这些类，作为他们的编写大纲去编写加减乘除这些函数的具体代码。根据整数，分数，小数各自的性质，做出各自的调整。这时数这个类，如果你给它里面的加减乘除函数的写了一些很粗糙简单的代码，就叫做父类，基础类。子类们“继承”了父类（把代码进行了复杂化）。如果没写，那这个类其实就只是个设计图，叫做抽象类。子类们“实现”了抽象类（把空空的设计变成了具体代码）。模版是什么？像C++这种复杂成狗的语言是强类型的，就是给变量进行了类型区分的，比如整数类型，双整数类型。很明显这两种变量所能容纳的数据体积是不一样的，单个函数不能通吃多种类型的参数，我们就可能会面临下面两套代码并存的局面。单整数类 {
单整数加
单整数减
单整数乘
单整数除
}
双整数类 {
双整数加
双整数减
双整数乘
双整数除
}
所以C艹跟其他强类型语言为我们提供了一个所谓模版功能：<变量类型>整数 {
<变量类型>加
<变量类型>减
<变量类型>乘
<变量类型>除
}
整数类等于把变量类型设置为整数，套上模版
双整数类等于把变量类型设置为双整数，套上模版 这样就写了一份代码，得到了两份类的代码。当然，弱类型的编程语言，比如JavaScript或者PHP是没有这种烦恼的，因为变量没有类型之分。但变量类型有时候还是很重要的，弱类型语言里就会出现类似数加字符串这种运算，可能并不是程序员的预期和本意，所以比起强类型性语言而言经常会出现很多无聊的BUG。再更新：上面发展出了父类之后，我们发现编程还是有问题的，小数类：小数类 {
加
减
乘
除
}
如果我们需要一个能自动实现结果四舍五入的小数计算类，同时又需要一个不需要的，怎么办呢，难道要写两个类吗？不要。所以做出了“实例”或者“对象”这一东西，首先把类改成：小数类 {
标识变量：是否四舍五入
标识变量：是否限定小数点后位数
构造函数（设置上面的标识）
加（会根据上面两个标识变量输出不同结果）
减（会根据上面两个标识变量输出不同结果）
乘（会根据上面两个标识变量输出不同结果）
除（会根据上面两个标识变量输出不同结果）
}
这样，我们就写一个类，但是通过构造函数，把一份代码，构造出了行为稍微有点不同的两个实例供我们使用，这时候名词来了，不能进行实例化微调化的类，叫做静态类，函数们的行为是固定的。不能实例化的类，其实只是函数们的一个集合归纳，只是对函数进行了整理，功能的强大和编码的*灵活度是不够的。能够进行实例化，变化出各种行为各自不大一样的实例的类，我们一般就把它们叫做类了，因为最常见。程序员们也就能保持代码简单的同时而又可以很方便进行代码行为微调了。

转载：https://blog.csdn.net/qq_40196241/article/details/78597645