java面向对象

Ⅰ java面向对象的特点

提问者采纳 1.抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
2.继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3.封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
4. 多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

谢谢采纳

Ⅱ java的面向对象是什么意思，能不能用通俗的话解释一下

面向对象的简单理解就是,你可以把现实中的每一件物品都看作是一个对象,这个物品的信息看作是对象属性,物品功能看作是对象方法

比如,身份证,这是一个对象,身份证上的姓名,籍贯地址,开卡所,有效期等等信息看作是这个对象的属性,身份证可以刷卡,那么刷卡这个动作就是身份证对象的方法/事件
再比如你开的车子,车子本身是对象,车辆类型,购买时间,里程数,手动/自动,耗油数,座位数,等等这些属于这两车子的信息都是属性,前进,转弯,后退,这些动作都是车辆方法;比如保养,年审,事故,修改里程公里数等等这些东西也是车辆的方法,但也同时是车辆的事件,所以这里单独称为事件方法,事件是方法,方法不一定是事件.不知道说的清楚吗

Ⅲ Java面向对象

面对对象就是：
把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。
对象即为人对各种具体物体抽象后的一个概念，人们每天都要接触各种各样的对象，如手机就是一个对象。
在面向对象的编程方式中，对象拥有多种特性，如手机有高度、宽度、厚度、颜色、重量等特性，这些特性被称为对象的属性。对象还有很多功能，如手机可以听音乐、打电话、发信息、看电影等工作功能，这些功能被称为对象的方法，实际上这些方法是一种函数。而对象又不是孤立的，是有父子关系的，如手机属于电子产品，电子产品属于物体等，这种父子关系称为对象的继承性。在编程中，把所有的问题看做对象，以人的思维方式解决。这种方式非常人性化，对象实际上就是一组数据的集合，并且数据都已经命名。这些数据根据就是对象的属性，可以被程序访问。对象还包括很多函数，这些函数被称为对象的方法，也可以被程序访问。不过在外部访问对象内的属性或方法，必须先引用对象，然后用点号访问对象的属性和方法
面向过程就是：
自顶向下顺序执行，逐步求精；其程序结构是按功能划分为若干个基本模块，这些模块形成一个树状结构；各模块之间的关系尽可能简单，在功能上相对独立；每一模块内部均是由顺序、选择和循环三种基本结构组成；其模块化实现的具体方法是使用子程序。程序流程在写程序时就已决定。

Ⅳ Java中面向对象到底是什么意思

一．面向对象：

1.何谓对象：在面向对象程序设计中，我们将问题空间中的元素以及他们在方案空间中的的表示物称作对象（object）
Alan Kay总结了smalltalk中对象的5大基本特征：
所有的东西都是对象。
程序是一大堆对象的集合，他们通过消息传递，各个对象之间知道要做些什么。
每个对象都分配有自己的存储空间，可容纳其他对象。
每个对象都有一个类型。
同一类的所有对象能接收相同的消息。
-----而所有的编程语言的最终目的是提供一种抽象方法----

2．对象的接口：我们向对象发出请求是通过它的接口定义的，对象的类型决定了它的接口形式。

3．OOP中唯一关心的：就是接口是什么，就像汽车的发动机一样，我们不必要知道它的结构是什么，只要它能工作就行了。所有的程序是由一定的属性（数据）和行为（方法）组成的，不同的对象访问通过函数调用来完成，对象间的所有交流都是通过方法调用，通过对封装数据对象，很大程度上提高复用率。

4．对象的3个主要特征：
behavior—说明这个对象能做什么。
State—当对象施加方法时对象的反映。
Identity---与其他相似行为对象的区分标志，每一个对象有唯一的indentity, 而这3者是相互影响的。

5．面向对象中最重要的思想就是类，类是模板是蓝图，从类中构造一个对象，即创建了一个类的实例。（类好比一个建材市场，其中有许多子类--各种各样的装饰材料，而我们装修自己的房子就要选择我们需要的材料，（为了建立我们自己的程序，我们必须选 择我们需要的类）这个比喻可以很形象的解释类是什么。

6．类之间的关系：
依赖关系：use-a A类中的一个方法操作了另一个类中的对象。
聚合关系：has-a A类中的对象包含B类的对象。
继承关系：is-a A继承了B类，此时A类不仅有了B类的方法，还加入了自己的方法。以便我们创建我们自己需要的对象。
Java中定义的每一个类都必须继承另一个类，使用关键字extends，如果一个类在定义中不现实使用关键字extends,这个类就会隐式继承Object类。Object类又叫根超类，或基类。，我们从根超类继承来的叫子类。Java中每个类都是根超类的子类。

8．接口（interface）规定了可对特定的对象发出哪些请求。

9．继承=重新使用接口：创建出一个数据类型后，当需要新建立一个数据类型去实现相同的功能，是很没有意义的一件事，此时对其克隆后，再根据情况改进实现自己的目的就是继承。

10．封装：就是把数据和行为结合在一起在一个包中，并对对象使用者隐藏数据的实现过程。Java用3个关键字来设置边界，从而进行对数据的隐藏。Public(共有)的定义任何人都可使用.private（私有）意味着除你自己，类型创建者及那个类型的内部函数成员可以访问外其他任何人使用都会产生错误。Friendly（友好）
意味在包(package)中是可以访问的。（以上过程也可叫方案隐藏）

11．引用（Handle）操控对象：
当创建一个引用时必须要对其进行初始化
例: String s=”happy”（未建立连接）
String s=new string(“happy”)与一个新的对象连接使用new 。此句建立了一个引用，并且连接引用并初始化对象 赋值字符串“happy”.

12.对象的创建及存在时间：数据存放的地点
1：寄存器-速度快，数量少，在cpu内部，我们对寄存器没有控制权。
2：堆栈：驻留长规内存中，堆栈指针下移建立新的内存，上移释放内存。
3：堆：常用内存池，保存对象，有极大的灵活性，java的数据就存放在此，但是要以时间及效率为代价。Java的对象建立是在程序运行时才决定。而c++是在设计时建立对象。
对象的生存时间（lifetime）java提出的垃圾收集器可以很好的发现无须再用的对象，使用GC（grabage collector）垃圾收集器。清除对象，释放内存。
为此我们就要付出一定的运行期的开销。

13.在此我们就会有这样一个印象,一个程序只是一系列对象的集合,他们的方法将其他对象作为自己的变量使用.

14.主要类型: java的主要类型有:boolean,char,byte,short,int,long,float,double,void.这些主类型的大小都不随机器的结构变化而变化,提供了java很好的可移植性.

15.字段方法:字段又叫数据成员,成员函数又叫方法,java的全部工作就是定义类,制作累得对象及发送消息.

16.一个程序只是一系列对象的集合,他们的方法将其他的对象作为自己的变量使用,而且将消息发给那些对象.

17.名字的可见性:为了使名字不重复,作者可以定义自己的库,一般用自己域名的倒写形式 如: COM.:Leeak.utility.foidles

18.static关键字:即使没有创建对象,也需要一愕能调用的方法,此时可以使用static

19.java.lang默认自动的导入每个java程序中

20.OOP中对象使对属性和方法的封装,对象具有信息的隐蔽的性质,对细节的隐藏,对象只需要知道去这样做,而不知道如何做的细节,类的方法应谨慎控制对java数据的访问,可以用get读取方法,用set修改方法.

21:pakage:Java API中每个类和接口属于一个特定的包,包实际上市对类和接口进行组织的目录结构,提供了一种软件复用机制.

22.创建可复用的类得步骤:1.定义一个public类
2.选择一个包名,并把pakage语句加到可复用的类的源码中.
3.编译这个类.
4.把可复用的类导入其他程序中即可.
23.java中提出在类定义的括号外的仅有2个语句,pakage和import.

24.软件的复用性,软件的复用性就是利用紫的已有的,定义良好的的经过仔细测试的文档清晰的可移植的易于获得的软件构件开发新的软件.

以上就是java面向对象的一些基本术语的概述,其中的有些部分可以扩展的更深,看过think in java的 朋友就会有此种感觉.此文章向对初学者阐述了面向对象的基本概念.对已是java程序员的朋友可以对他们的基本知识做以回顾.

Ⅳ JAVA面向对象的概念

可以理解成，把每种事物都看成是整体，所谓整体就是由一系列属性和行为组成，例如人，你可以看成由胳膊，腿，等不细分了，组成的对象。
这样人就有胳膊，腿等属性了，跑，跳。可以看做行为。
因为每种具体的事物都可以细分，所以万物皆对象。
而类只是用来定义对象有什么的，只是抽象概念。

Ⅵ 如何理解JAVA中的面向对象谢谢！

java语言就是一门编程语言，用来解决现实当中各种复杂的业务逻辑问题。
Java 在特定情况下解决了特定平台间的跨平台问题，解决方法是把 Java 本身做成一个平台。然后，只要把 Java 平台本身部署到目标机器，那么应用理论上就可以用了，这个方法对不同 flavor 的 Unix 系统之间的程序移植带来了很多好处。——这所有的好处都来自服务器领域。——Java 虚拟机把这些“型号不同但实质上等价”的服务器虚拟成一致的。但 Java 无法解决那些“实质上就不一样的设备”之间的兼容性。
Java 最初的目标，甚至都不是为了把 Windows 移植到 Linux，而是为了让不同 flavor 的 Unix 之间能够做到二进制兼容。但无论如何，不同的 Unix 本质上都是 Unix，他们之间实现二进制兼容相对比较现实。但诸如 Linux/Windows/OSX 这样本质区别很大的平台，二进制兼容很大程度上只是过于美好的幻想。他们在一些系统核心调用方面可能存在完全不同的机制，以至于你为了选择一个所有系统可用的方式必须牺牲最优效率。

Ⅶ Java面向对象

代码如下：

classPerson{
	
	protectedStringname;
	
	protectedintage;
	
	protectedStringaddress;

	publicPerson(Stringname,intage,Stringaddress){
		this.name=name;
		this.age=age;
		this.address=address;
	}
	
	publicvoidsayHi(){
		System.out.println(this.name+","+this.age+","+this.address);
	}
}

classStudentextendsPerson{
	
	privateStringstuId;
	
	publicStudent(StringstuId,Stringname,intage,Stringaddress){
		super(name,age,address);
		this.stuId=stuId;
	}
	
	publicvoidsayHi(){
		System.out.println(this.stuId+","+this.name+","+this.age+","+this.address);
	}
}

classTeacherextendsPerson{
	
	privatefloatsalary;
	
	publicTeacher(Stringname,intage,Stringaddress,floatsalary){
		super(name,age,address);
		this.salary=salary;
	}
	
	publicvoidsayHi(){
		System.out.println(this.name+","+this.age+","+this.address+","+this.salary);
	}
}

classDoctorextendsPerson{
	
	privateStringlevel;

	publicDoctor(Stringname,intage,Stringaddress,Stringlevel){
		super(name,age,address);
		this.level=level;
	}
	
	publicvoidsayHi(){
		System.out.println(this.name+","+this.age+","+this.address+","+this.level);
	}
}

publicclassTest{

	publicstaticvoidmain(String[]args){
		
		Student[]students=newStudent[2];
		students[0]=newStudent("201803010001","小明",20,"广东深圳");
		students[1]=newStudent("201803010002","小王",22,"上海");
		
		for(Studentstudent:students){
			student.sayHi();
		}
		
		Teacher[]teachers=newTeacher[2];
		teachers[0]=newTeacher("张三",30,"广东广州",5000);
		teachers[1]=newTeacher("李四",35,"广东广州",6000);
		
		for(Teacherteacher:teachers){
			teacher.sayHi();
		}
		
		Doctor[]doctors=newDoctor[2];
		doctors[0]=newDoctor("张三",30,"北京","主治医师");
		doctors[1]=newDoctor("李四",35,"上海","主任医师");
		
		for(Doctordoctor:doctors){
			doctor.sayHi();
		}
	}
}

Ⅷ JAVA中什么是面向对象

在java的学习中，面向对象应该是java技术的重中之重，虽然在生活中没有对象可以面对，但在技术中还是要一直接触面对对象，而且不可避免。今天对面向对象来了一个小总结。

一、面向对象的特点：
1、将复杂的事情简单化。
2、面向对象将以前的过程中的执行者，变成了指挥者。
3、面向对象这种思想是符合现在人们思考习惯的一种思想。
过程和对象在我们的程序中是如何体现的呢？过程其实就是函数；对象是将函数等一些内容进行了封装。
二、匿名对象使用场景：
1、当对方法只进行一次调用的时候，可以使用匿名对象。
2、当对象对成员进行多次调用时，不能使用匿名对象。必须给对象起名字。
三、在类中定义其实都称之为成员。成员有两种：
1、成员变量：其实对应的就是事物的属性。
2、成员函数：其实对应的就是事物的行为。
所以，其实定义类，就是在定义成员变量和成员函数。但是在定义前，必须先要对事物进行属性和行为的分析，才可以用代码来体现。
四、类中怎么没有定义主函数呢？
注意：主函数的存在，仅为该类是否需要独立运行，如果不需要，主函数是不用定义的。主函数的解释：保证所在类的独立运行，是程序的入口，被jvm调用。
五、成员变量和局部变量的区别：
1、成员变量直接定义在类中；局部变量定义在方法中，参数上，语句中。
2、成员变量在这个类中有效；局部变量只在自己所属的大括号内有效，大括号结束，局部变量失去作用域。
3、成员变量存在于堆内存中，随着对象的产生而存在，消失而消失；局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。
六、构造函数和一般函数有什么区别呢？
1、两个函数定义格式不同。
2、构造函数是在对象创建时，就被调用，用于初始化，而且初始化动作只执行一次。
一般函数，是对象创建后，需要调用才执行，可以被调用多次。
七、创建一个对象都在内存中做了什么事情？
1、先将硬盘上指定位置的Person.class文件加载进内存。
2、执行main方法时，在栈内存中开辟了main方法的空间(压栈-进栈)，然后在main方法的栈区分配了一个变量p。
3、在堆内存中开辟一个实体空间，分配了一个内存首地址值。new
4、在该实体空间中进行属性的空间分配，并进行了默认初始化。
5、对空间中的属性进行显示初始化。
6、进行实体的构造代码块初始化。
7、调用该实体对应的构造函数，进行构造函数初始化。
8、将首地址赋值给p ，p变量就引用了该实体。(指向了该对象)

Ⅸ Java面向对象的理解

通过你的描述根本看不明白你在说什么
不一定老师说的就对，老师一般头脑里有个“正确”做法，不一样的都被看作“不好”做法。
面向对象的重要作用是封装，一个类、方法一般只做一件事。如果你能做到对象内部管理其自身状态和逻辑，对外只暴露简单接口，那我觉得就算好的对象

Ⅹ 介绍一下java的面向对象

1、面向对象

面向对象（Object Oriented）是一种新兴的程序设计方法，或者是一种新的程序设计规范(paradigm)，其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。从现实世界中客观存在的事物（即对象）出发来构造软件系统，并且在系统构造中尽可能运用人类的自然思维方式。

2、对象

对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。

类的实例化可生成对象，一个对象的生命周期包括三个阶段：生成、使用、消除。

当不存在对一个对象的引用时，该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。当系统内存用尽或调用System.gc( )要求垃圾回收时，垃圾回收线程与系统同步运行。

3、类

类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性和方法两个主要部分。

Java中的类实现包括两个部分：类声明和类体。

类声明

继承

子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。

Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承。

继承实现了代码的复用。

Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。

子类不能继承父类中访问权限为private的成员变量和方法。

子类可以重写父类的方法，即命名与父类同名的成员变量。

Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。super 的使用有三种情况：

访问父类被隐藏的成员变量，如：super.variable;

调用父类中被重写的方法，如：super.Method([paramlist]),super()调用父类构造方法;

调用父类的构造函数，如：super([paramlist]);

多态

对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或方法在父类及其各个子类中具有不同的语义。例如："几何图形"的"绘图"方法，"椭圆"和"多边形"都是"几何图"的子类，其"绘图"方法功能不同。

Java的多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。

编译时多态：在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。

运行时多态：由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。

重载（Overloading）

方法重载是让类以统一的方式处理不同数据类型的手段。

一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法。

返回值类型可以相同也可以不相同，无法以返回型别作为重载函数的区分标准。

重写（Overriding）

子类对父类的方法进行重新编写。如果在子类中的方法与其父类有相同的的方法名、返回类型和参数表，我们说该方法被重写 (Overriding)。

如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

子类函数的访问修饰权限不能低于父类的。