java面向对象项目

❶ java中面向对象到底是什么意思求解，谢谢。

Java面向对象思想和三大特性

面向对象：

1、面向对象

面向对象是一种程序设计思想，计算机程序的设计实质上就是将现实中的一些事物的特征抽离出来描述成一些计算机事件的过程，这种抽象的过程中，我们把具体的事物封装成一个一个的整体进行描述，使被描述的对象具备一些系统性、整体性的的行为和特征，我们把这种设计思想称为面向对象。

2、面向对象与面向过程

2.1、面向过程是早期的程序语言设计思想，该思想强调事物的行为细节，即程序的设计不需要封装成一个个的整体，而是将整个程序描述成一个行为，所有行为细节都按照固定方式一步一步的执行，执行程序就是执行某一行为的过程。

2.2、面向对象和面向过程都是一种思想，面向对象是相对于面向过程而言的，

面向过程强调的是具体的功能行为，而面向对象将功能封装进对象，强调具备了功能的对象，面向对象是基于面向过程的，但面向对象思想更接近于现实场景。

三大特性：

1、封装

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

1.2、封装的好处：

（1）将外界的变化隔离，使程序具备独立、安全和稳定性。

（2）便于设计者使用，提高代码的复用性

1.3、封装的原则

（1）将不需要对外提供的内容都隐藏起来

（2）把实现细节隐藏，提供可以对其进行访问公共的方式

1.4、封装的方式

将某一功能、属性抽离出来，独立写成单独的方法或类

设置访问权限

（1）设置访问权限可以限定该功能或属性可以被特定的访问者访问，保证了程序的安全性和功能的稳定性。

（2）java对类和类中成员都定义了特定的访问修饰符

类：public（公共的）、default（默认的，不写就默认是它）

类中成员：public、protected、default（默认的）、private

注：类的访问修饰符可以不写（默认的），也可以写public（公共的），一个java文件中只能有一个被public修饰的类，且被public修饰的类类名必须要跟文件名一致（包括大小写一致），否则编译会出错，为了方便阅读，类名的命名规范是单词的首字母大写，多个单词组成的类名每个单词的首字母都大写

2、继承

2.1、继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的功能，或者说将事物的共性的功能和属性抽取出来定义成一个父类，让后来具有更多样化实现的子类继承父类。

2.2、继承的作用：

（1）父类具备的方法子类可以直接继承过来，不用重新书写，提高了代码的复用性

（2）让类与类之间产生关系，有了关系才有多态的实现

（3）Java中只支持单继承，不支持多继承，因为多继承存在安全隐患（当多个父类存在同个功能时，子类不确定要运行哪一个），Java支持多层继承，即父类还可以继承其他类，java用另一种机制解决单继承的局限性，即多实现

2.3、对继承体系的使用

（1）想要使用体系，应该先查阅父类，因为父类定义了该体系的共性功能，了解了父类的功能，就基本可以使用该体系的功能了

（2）在具体调用时，要创建子类的对象，因为有可能当父类是抽象类时父类不能创建对象，而且子类具备更丰富、更具体的功能实现

2.4继承的特点

2.4.1覆盖（重写）

2.4.1.1如果子父类中的成员一致时，子类成员会覆盖父类成员

2.4.1.2当子类继承父类时，沿袭父类的功能到子类中，但子类对该功能的实现细节不一致，子类可以保留父类对该功能的定义，重写功能的内容

2.4.1.3覆盖与重载：重载只看参数列表，其他一致参数列表不一致为重载，而重写子父类的参数必须要一致

2.4.2this与super

this表示当前对象的引用，super表示当前对象父类的引用

2.5子父类中的构造函数

2.5.1构造函数不能重写

2.5.1.1构造函数第一行有一条隐式的语句super()/this()

2.5.1.2在对子类对象进行初始化时，父类构造函数也会运行，因为子类中的构造函数默认第一行有一条隐式的super()语句，这样方便子类构造时先获取到父类的共性属性

2.5.1.3super()一定要定义在子类构造函数的第一行，当没有默认的空参数构造函数，要手动指定

2.6、注意事项：

2.6.1千万别为了获取其他类中的功能而继承，必须是类与类间有所属关系才可以继承。

2.6.2子类覆盖父类时必须保证子类权限大于等于父类，才可以覆盖，否则编译失败

2.6.3子类静态成员只能覆盖父类静态成员

2.7final关键字

2.7.1final关键字可以修饰类、函数和变量

2.7.2被final修饰的类不可以被继承（继承打破了封装性）

2.7.3被final修饰的方法不可以被复写

2.7.4被final修饰的变量只能被赋值一次，既可以修饰成员变量，也可以修饰

2.8Object类

2.8.1java中有一个特殊的类，Object类，它是所有对象的超类（根类），Object类中定义了所有对象的共性成员

2.8.2Object类中的方法

equals()比较两个对象是否相同

toString()返回该对象的字符串表示形式

getClass()获取该对象对应的字节码文件对象

hasCode()获取该对象的哈希码值

2.9类间的体系关系

继承、聚集（聚合）、组合

2.9.1继承：

指的是一个类继承另外的一个类的功能，并增加它自己的新功能或改写旧有功能的具体实现，继承是类与类之间最常见的关系。

2.9.2聚合：

指的是整体与部分的关系。通常在定义一个整体类后，再去分析这个整体类的组成结构。从而找出一些组成类，该整体类和组成类之间就形成了聚合关系。例如足球队中的足球队员就是聚合关系。

2.9.3组合：

也表示类之间整体和部分的关系，但是组合关系中部分和整体具有统一的生存期。一旦整体对象不存在，部分对象也将不存在。部分对象与整体对象之间具有共生死的关系。例如人的各个身体器官之间的关系。

3、多态

3.1、多态的定义；某一类事物具备的多种表现形态（猫、狗和动物）

3.2、java中多态的表现形式

父类的引用指向自己的子类对象

父类的引用接收自己的子类对象

3.3、多态的前提

必须是类与类之间有关系，要么继承，要么实现

子父类间的成员存在覆盖

3.4、多态的好处与缺陷

好处是提高了程序的扩展性，缺陷是只能使用父类的引用访问父类的方法，无法访问子类的特有方法。

3.5、多态的应用

类型转换

向上转型，自然转型

向下转型，强制父类引用向下转型

3.6、特点

（1）多态中成员函数的特点

编译时看引用变量所属的类中是否有方法

运行时看对象所属类的方法

（2）多态中成员变量的特点

无论编译或运行时都参看右边

多态中静态成员函数的特点

编译或运行时都参看左边

3.7、多态的扩展示例

数据库操作（各种数据库）：定义数据库的父类型，由哪类型的数据库调用就由该子类实现其具体操作内容。

我有一个微信公众号，每天都会分享一些Java相关的干货文章，还有海量学习资源。
如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。

❷ java: 谈谈你对面向对象的理解

java万事万物皆对象（一种理念;只可意会，不可言传！）。
对象是数据与只能处理这些数据的方法的封装（一个原子单元），类是程序员提供给系统的一类对象相似的对象的描述(描述)，程序开始运行之时，想一下程序中是不是未存在任何对象，就连对象的声明（用代码表示具体的对象）也没有，单单就存在对象描述模板（即是：类），所以我们可以通过模板，叫系统new（构造）一个具体的对象来使用。
特别提醒一点：千万要揣摩一下这句话（对象是数据与只能处理这些数据的方法的封装）。
具体可以结合面向对象的四大特征进行理解：封装 继承 多态 抽象

❸ 请问用java语言写的项目,毕业论文可以按面向过程的结构来写吗

按面向过程写的话，需求不能有大的改动，要不然可能牵一发动全身，因为面向过程的耦合度太高了；也就是说需求要一开始就比较明确；

既然用Java写项目，还是用面向对象好一些，毕竟Java在面向对象编程方面有优势；面向对象可读性较高，好修改和维护；

❹ java 面向对象

import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
Score s = new Score();
System.out.println("最大值："+s.getMax());
System.out.println("最小值："+s.getMin());
System.out.println("平均值："+s.getAvg());
System.out.println("均方差值："+s.getVar());
}
}
class Score{
private double max;//最大值
private double min;//最小值
private double avg;//平均值
private double var;//均方差
double[] d;//成绩数组
public Score() {
Scanner input = new Scanner(System.in);
System.out.println("请输入数组的长度");
int length= input.nextInt();
double[] dd=new double[length];
for (int i = 0; i < dd.length; i++) {
System.out.println("请输入第们课"+(i+1)+"的成绩");
dd[i]=input.nextDouble();
}
this.d=dd;
}
public double getMax() {
max=d[0];
for (int i = 1; i < d.length; i++) {
if (d[i]>max) {
max=d[i];
}
}
return max;
}
public double getMin() {
min=d[0];
for (int i = 1; i < d.length; i++) {
if (d[i]<min) {
min=d[i];
}
}
return min;
}
public double getAvg() {
double sum=0;
for (int i = 0; i < d.length; i++) {
sum+=d[i];
}
avg=sum/d.length;
return avg;
}
public double getVar() {
double avg =getAvg();
for (int i = 0; i < d.length; i++) {
var+=(Math.pow((avg-d[i]), 2));
}
var=Math.pow(var,0.5);
return var;
}
}

❺ java动物特性的面向对象描述 项目

定义LandAnimal接口和WaterAnimal接口 ,只定义个接口好定义，只是你的题目用不到啊。（没水生和陆生啊）
下面是定义的ANIMAL类，实现了他们共有的属性。CAT,FROG没说出来啊，自己定义吧。

public class ANIMAL {
public String name;
public boolean mammal; // 哺乳动物
public boolean carnivorous;// 肉食动物
public String mood;
public int logs;

public void setName(String name) {
this.name = name;
}

public void setMammal(boolean mammal) {
if (mammal) {
System.out.println(name + "是哺乳动物");
} else {
System.out.println(name + "不是哺乳动物");
}
}

public void setCarnivorous(boolean carnivorous) {
if (carnivorous) {
System.out.println(name + "是肉食动物");
} else {
System.out.println(name + "不是肉食动物");
}
}

public void setMood(String mood1, String mood2, String mood3) {
System.out.println(name + "通常的情况下,和人打招呼的方式为:" + mood1);
System.out.println(name + "被抚摸情绪好的时候,打招呼的方式是:" + mood2);
System.out.println(name + "烦躁的时候会:" + mood2);

}
public void setLogs(int logs){
System.out.println(name+"有"+logs+"条腿");
}

}

下面是 狗的那个类继承类ANIMAL：
public class Dog extends ANIMAL{

public Dog(){

}

public static void main(String[] args) {
ANIMAL dog = new Dog();
dog.setName("狗");//设置动物名字
dog.setMammal(true);//设置是否Mammal
dog.setCarnivorous(true);//设置是Carnivorous
dog.setMood("摇摇尾巴", "旺旺叫", "呜呜叫");//设置 在3种不同情况下的动作
dog.setLogs(4);
}

}
输出：
狗是哺乳动物
狗是肉食动物
狗通常的情况下,和人打招呼的方式为:摇摇尾巴
狗被抚摸情绪好的时候,打招呼的方式是:旺旺叫
狗烦躁的时候会:旺旺叫
狗有4条腿

其他的动物 同样的原理。

补充：
public interface LandAnimal {

}
public interface WaterAnimal {

}
你的输出内容中 没用的到 （没有显示这两个接口有关信息，没有说明他是水生，陆生）

如果是狗的 那么直接 那个类 implements LandAnimal
public class Dog extends ANIMAL implements LandAnimal{}就行了 ，说明他是陆生的一种标志
这样就像 java.io.Serializable这个接口 ，一种标志。

❻ Java面向对象程序设计 这句话中的对象指的是什么

对象是类的实例的意思
面向对象

面向对象是一种新兴的程序设计方法，或者说它是一种新的程序设计范型，其基本思想是使用对象，类，继承，封装，消息等基本概念来进行程序设计。

它是从现实世界中客观存在的事物（即对象）出发来构造软件系统，并在系统构造中尽可能运用人类的自然思维方式，强调直接以问题域（现实世界）中的事物为中心来思考问题，认识问题，并根据这些事物的本质特点，把它们抽象地表示为系统中的对象，作为系统的基本构成单位（而不是用一些与现实世界中的事物相关比较远，并且没有对应关系的其它概念来构造系统）。这可以使系统直接地映射问题域，保持问题域中事物及其相互关系的本来面貌。

它可以有不同层次的理解：

从世界观的角度可以认为：面向对象的基本哲学是认为世界是由各种各样具有自己的运动规律和内部状态的对象所组成的；不同对象之间的相互作用和通讯构成了完整的现实世界。因此，人们应当按照现实世界这个本来面貌来理解世界，直接通过对象及其相互关系来反映世界。这样建立起来的系统才能符合现实世界的本来面目。

从方法学的角度可以认为：面向对象的方法是面向对象的世界观在开发方法中的直接运用。它强调系统的结构应该直接与现实世界的结构相对应，应该围绕现实世界中的对象来构造系统，而不是围绕功能来构造系统。

从程序设计的角度来看，面向对象的程序设计语言必须有描述对象及其相互之间关系的语言成分。这些程序设计语言可以归纳为以下几类：系统中一切皆为对象；对象是属性及其操作的封装体；对象可按其性质划分为类，对象成为类的实例；实例关系和继承关系是对象之间的静态关系；消息传递是对象之间动态联系的唯一形式，也是计算的唯一形式；方法是消息的序列。

❼ java是什么东西

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。
Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等 。
Java的工作原理由四方面组成：
（1）Java编程语言
（2）Java类文件格式
（3）Java虚拟机
（4）Java应用程序接口
当编辑并运行一个Java程序时，需要同时涉及到这四种方面。使用文字编辑软件（例如记事本、写字板、UltraEdit等）或集成开发环境（Eclipse、MyEclipse等）在Java源文件中定义不同的类 ，通过调用类（这些类实现了Java API）中的方法来访问资源系统，把源文件编译生成一种二进制中间码，存储在class文件中，然后再通过运行与操作系统平台环境相对应的Java虚拟机来运行class文件，执行编译产生的字节码，调用class文件中实现的方法来满足程序的Java API调用 。

❽ java使用面向对象写一个登录注册查询的功能

import java.util.Scanner;/**
* 采用面向对象的方式 写一个登录系统
* @author Administrator
*
*///用户信息class UserInfo{ public static String[] user = new String[10]; public static String[] passwd = new String[10];
public UserInfo() { this.user[0] = "test"; this.passwd[0] ="123456";

}

}//找回密码class ZhaoHui extends UserInfo{ public static void zhaohui() {
Scanner s = new Scanner(System.in);
System.out.println("请输入你要找回的用户名：");
String zname = s.nextLine(); for(int i=0;i<2;i++) { if(user[i].equals(zname)) {
Scanner ss = new Scanner(System.in);
System.out.println("恭喜你!成功找回密码，请输入："+"'张哥最帅'"+" 查看密码");
String zgzs = ss.nextLine();
if("张哥最帅".equals(zgzs)) {
System.out.println(passwd[i]);
}else {
System.out.println("请输正确！");
}
}else if(user[i]!=zname){
System.out.println("用户名不存在！"); return;
}
break;
}
}
}//修改密码 class XiuGai extends UserInfo{ public static void xiugai() {

Scanner s =new Scanner(System.in);
System.out.println("请输入您要修改的密码：");
String xpasswd = s.nextLine(); for(int i=0;i<2;i++) {
passwd[i] = xpasswd; if(xpasswd.equals(passwd[i])) {
System.out.println("恭喜你，修改成功！"); break;
}else {
System.out.println("修改密码失败"); break;
}
}
}
}//查询用户class ChaXun extends UserInfo{
public static void select() { for(int i=0;i<2;i++) {
System.out.println("当前用户："+user[i] +"\n"+ "当前密码："+passwd[i] );
i++; break;
}
}
}//注册class ZhuCe extends UserInfo{
public static void regist() {
Scanner ss = new Scanner(System.in);
System.out.println("请输入用户名：");
String suser = ss.nextLine();
System.out.println("请输入密码：");
String spasswd = ss.nextLine();
for(int i=0;i<user.length;i++) {

user[i] = suser;
passwd[i] = spasswd;
System.out.println("注册成功!"); break;

}
}
}//登录class Loginc extends UserInfo{
public static void login() { int flag = 1;
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名：");
String users = scanner.nextLine();
System.out.println("请输入密码：");
String passwds = scanner.nextLine();
for(int i=0;i<UserInfo.user.length;i++) { if(user[i].equals(users) && passwd[i].equals(passwds)) {
System.out.println("登陆成功！"); break;
}
System.out.println("登陆失败！"); break;
}

}
}//主界面class ZhuJieMian{ public static void Start() {
Loginc Loginc = new Loginc();
ZhuCe ZhuCe = new ZhuCe();
ChaXun ChaXun = new ChaXun();
XiuGai XiuGai = new XiuGai();
ZhaoHui ZhaoHui = new ZhaoHui();

Scanner s = new Scanner(System.in); while(true) {
System.out.println("|"+ "\t"+ "\t"+ "\t"+ "\t"+ "\t"+ "\t"+ "\t"+"\t"+"|");
System.out.println("|"+"\t" + "测试用户名:test 测试密码:123456" + "\t"+ "\t"+ "\t"+ "\t"+"|");
System.out.println("|" + "\t"+ "请输入[1-5]进行操作 1.登录|2.注册|3.查询当前用户|4.修改密码|5.找回密码 " + "\t"+"|");
System.out.print("请输入:"); int temp = s.nextInt();
switch(temp) { case 1:Loginc.login(); break; case 2:ZhuCe.regist();; break; case 3:ChaXun.select();; break; case 4:XiuGai.xiugai();; break; case 5:ZhaoHui.zhaohui();; break; default:System.out.println("错误！请重写输入正确的数字进行操作！");

}
}
}

}public class LoginTest { public static void main(String[] args) {
ZhuJieMian zjm = new ZhuJieMian();
zjm.Start();

}

}

❾ 介绍一下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关键字，该关键字引用了当前类的父类。

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