java面向对象总结修订

面向对象

面向对象是一种思想，能让复杂的问题简单化，让我们角色从执行者变成指挥者，不要知道过程，只要知道结果。（一切皆对象。）

描述一个事物，其实就是在描述事物的属性和行为。

对象的特点在于封装数据，数据包含着属性和行为。

我们用类来描述一个事物，然后引用类来建立一个对象。

也可以在本类建立一个主函数来中创建本类对象，这个叫在本类中创建本类对象。

一般一个程序可以由很多个类组成，也可以有多个主函数，但一般有一个主函数就可以。

格式：引用类名对象名=new 构造函数名（参数）；

例：class DuiXiang{}

则建立对象为：DuiXiang mingZi=new DuiXiang（）；

如果要实现功能，则格式为：

mingZi.变量或函数名（）；

（string是java中的字符串。String类是不可变的,对String类的任何改变,都是返回一个新的String类对象。String 对象是System.Char 对象的有序集合，用于表示字符串。String 对象的值是该有序集合的内容，并且该值是不可变的。）面向对象主要的部分：(类和对象的关系，封装（机箱故事），继承，多态，构造函数，this，static，内部类，抽象类，接口)

面向对象之封装

函数是最小的封装体。类也是一个封装体。

private:私有的，权限修饰符，用来修饰类中的成员（成员变量、成员函数），其只在本类中有效。

每个成员变量通常都会对应两个访问方式：一个设置，一个获取。

注意：私有仅是封装的一种表现形式。

因为语句都必须在函数内，所以，私有化后，再提供访问方式，就可以在访问方式的函数内实现变量控制。这样就提高代码的健壮性。

一般进行封装，要对类中的大部分属性都隐藏，最低权限是private。

类里有一个setXxx函数（一般返回值是void，直接获取，要带参数）和getXxx 函数（有返回值类型，但一般没参数,getXxx之后一般用一个变量来接收:string x=p.getXxx

），那代表一定有一个私有化属性。

成员变量都有初始化值，局部变量可以没有。

举例：

class XueSheng

{

private String name；

public void setName(String name)//这个函数方便以后赋值

{

https://www.wendangku.net/doc/d72789144.html,=name;

}

public String getName()//这个函数是方便以后有需要调用的，比如以后要打印name的值

{

return name;

}

构造函数：

函数名与类名一致，不用返回值类型，不可以用return，主要用来初始化对象。对象一建立，就默认调用其构造函数。一个对象一建立，就有其默认的属性和行为。（如一个人刚出生就会呼吸，哭...）。

如果我们没有指认，那么类建立就会默认建一个构造函数（类名（）{}），不然对象无法初始化，也就无法建立。（注意：只要我们有指认，那么就不会默认建构造函数）

其与普通函数的区别除了写法上之外：

1，构造函数只在对象建立时运行一次，不再运行了，而普通函数可以调用多次，另外，构造函数是用来初始化对象的，而一般方法是用来添加对象具备的功能。何时我们要手动添加构造函数：当我们分析事物时，该事物存在一些特性或行为，那么我们就给其定义一个构造函数，如果有变量参与运算，那么我们就给构造函数定义一个参数。

构造函数写法举例：

class Person

{

Person(String name,int age)

//注意：在新建一个对象时要加上参数进行区分，因为一个类可以放很多个构造函数。

//比如：Person p =new Person（"fada",20）

{

https://www.wendangku.net/doc/d72789144.html, = name;

this.age = age;

}

构造代码块：

1，所有对象在建立时都先执行构造代码块初始化，再执行构造函数初始化。

2，作用：当所有对象有共性时，那么就可以定义一个构造代码块（例如：所有小孩先出来就是哭，然后才有其它的属性）

构造代码块的写法(就是在类里面用一个大括号)举例：

class Person

{

{

System.out.print("fada")

//这样一写，那么以后每次建立一个构造函数时便先初始化这个构造代码块

}

}

this关键字的用法

This在类中就是三个代表：代表对象的成员变量，在函数中代表对象调用函数，代表类中的构造函数。

格式：this.变量=变量；

this是用来区分局部变量和成员变量同名时的关键字，因为如果在构造函数里比如（name=name），那么其是赋值给他本身，而不是赋值给类里面的name。

何是用this？当定义类中的函数时，需要调用该函数的对象时，这个时候就用this 来表示这个对象。

但凡本类功能内部使用到了本类对象，用this表示。

看到this就是有代表对象，代表哪个对象就看其所在功能被哪个对象调用。

这样就知道谁在参与运算。

例：

class Person

{

private String name;

Person(String name)

{

https://www.wendangku.net/doc/d72789144.html, = name;//https://www.wendangku.net/doc/d72789144.html,=https://www.wendangku.net/doc/d72789144.html,；

}

}

class PersonDemo3

{

public static void main(String[] args)

{

Person p1 = new Person("fada");

this的应用之定义类中函数的调用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。

但凡本类功能内部使用了了本类对象，都用this表示。

例：

class Person

{

private String name;

Person(String name)

{

https://www.wendangku.net/doc/d72789144.html, = name;//https://www.wendangku.net/doc/d72789144.html,=https://www.wendangku.net/doc/d72789144.html,；

this.fada();//其实就==p1.fada();

//这里写这p1是因为p1这个对象在调用这个函数。一句话，谁调用它就在代表谁。

}

private int age;

Person(int age)

{

this.age = age;

}

public void fada()

{

System.out.println("fada");

}

/*

需求：给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。

*/

public boolean compare(Person p)

{

return this.age==p.age;

}

}

class PersonDemo

{

public static void main(String[] args)

{

Person p1 = new Person(20);

Person p2 = new Person(25);

//因为是两个人比，所以要先建立两人的对象

boolean b = https://www.wendangku.net/doc/d72789144.html,pare(p2);

//这里定义了一个布尔型变量去接收p1调用compare函数的值

System.out.println(b);

另一种this用法：格式this（变量）

用于构造函数间的相互调用，而且只能放在构造函数的第一行。

然后先初始化其this调用的构造函数，再初始化本身的构造函数。

其实this(变量)；=new 构造函数名（变量）；（因为所有构造函数名是一样的，都是重载函数，所以，通过变量来标记构造函数，用this去引用）

例：

class Person

{

private String name;

private int age;

Person()

{

System.out.println("person run");

}

Person(String name)

{

This();

https://www.wendangku.net/doc/d72789144.html, =name;

}

}

Static（静态）关键字：

static是一个修饰符：

三种修饰：修饰类的变量、方法和构造代码块。静态方法只能直接引用和访问静态变量和方法

注意（函数即方法，对象也叫实例）

有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。声明为static的变量称为静态变量或类变量。可以直接通过类名引用静态变量，也可以通过实例名来引用静态变量，但最

好采用前者，因为后者容易混淆静态变量和一般变量。静态变量是跟类相关联的，类的所有实例共同拥有一个静态变量。关键点：静态变量与实例变量的区别：静态变量也叫类变量，为所有对象所共有，所以一个对象的变量值改变，那么所有对象的值一起发生改变。

而实例变量则是各自独立的不受影响。

声明为static的方法称为静态方法或类方法。静态方法可以直接调用静态方法，访问静态变量，但是不能直接访问实例变量和实例方法。静态方法中不能使用this 关键字，因为静态方法不属于任何一个实例。静态方法不能被子类的静态方法覆盖。

特有属性随着对象存储于堆内存中，而static修饰后的属性，存在于方法区.

什么时候使用静态修饰符？

当对象中出现共享数据时，使用静态修饰。

但对象内的特有数据要定义成非静态存在于堆内存中。

而对于方法时：

当功能内部没有访问到非静态数据时，（即对象的特有数据）

那么可以使用静态修饰。

静态代码块：

用于给类做初始化的。不管有没有对象都执行，只要调用了类里面成员或方法，就会执行，而且优先于主函数，优先执行级别最高。

例：

class JingTai

{

static int age;

static String name;

static//静态代码块初始化类的，所以最先运行。

{

System.out.println("name="+name);

}

//下面是构造代码块，第二个运行

{

System.out.println("age="+age);

}

public static void jing(int x)//被对象调用，第三个运行。

{

x =age+1;//因为age是静态的，所以能调用

System.out.println("x="+x);

}

}

class FaDa

{

public static void main(String[] args)

{

JingTai p =new JingTai();

p.jing(2);

}

}

文档注释：

文档注释有编译工具进行，具体一个要注意的地方是：类名前必须要有public 修饰。要编译的方法名必须有public 修饰

javadoc注释标签语法

@author 对类的说明标明开发该类模块的作者

@version 对类的说明标明该类模块的版本

@see 对类、属性、方法的说明参考转向，也就是相关主题

@param 对方法的说明对方法中某参数的说明

@return 对方法的说明对方法返回值的说明

@exception 对方法的说明对方法可能抛出的异常进行说明

命令是：javadoc -d 存放目录名称-author -version 类名.java

/**

这是一个静态修饰符static的应用说明

@author 李四

@version V1.1

*/

/**

这是一个测试类

*/

public class JingTai

{

/**

空参数构造函数

*/

/**

age 一个整数型变量

*/

public static int age;

/**

name 一个字符串型变量

*/

public static String name;

static

{

System.out.println("name="+name);

}

{

System.out.println("age="+age);

}

/**

打印x的值

@param x 接收一个int型整数

*/

public static void jing(int x)

{

x =age+1;

System.out.println("x="+x);

}

}

注意：main方法作为程序入口，应该在public的类Test中定义

设计模式：

做一个模式，使其能解决一类问题，这样，碰到类似的问题，直接套就可以了。java中23种设计模式：

举例：

单例设计模式：解决一个类在内存只存在一个对象。不再新生成。

思路：

1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象

2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

步骤：

1，将构造函数私有化。

2，在类中创建一个本类对象。

3，提供一个方法可以获取到该对象。

两种方式：

饿汉式

class Er

{

private Er(){};

private static Er e =new Er();

public static Er getEr()

{

return e;

}

}

懒汉式

class Er

{

private Er(){};

private static Er e =null;

public static Er getEr()

{

if(e==null)

e=new Er();

return e;

}

}

虽然懒汉式可以延迟加载对象，但为代码的简洁性和安全性，日常用的还是饿汉式。

继承

继承就是将两个类的共性描述提取出来，单独进行描述，从而简化代码，提高复用性。

格式：class 子类名extends 父类名

关健字为extends ：继承

判断两个类是否有所属关系，那么我们就继承一下，看父类所具有的内容属性，子类是否全都需要具备。如果是，那么他们所属关系成立，就是继承。

注意：千万不要为了获取其他类的功能，简化代码而继承。

必须是类与类之间有所属关系才可以继承。所属关系is a。

例如：

class A

{

//void demo1(){}

void demo2(){}

}

class B

{

//void demo1(){}

void demo3(){}

}

我们可以让B继承下A，但发现，A中还具有demo2这个方法是B所不具备的，所以他们俩的继承关系不成立，但我们可以把两个类的共性提取出来，成为一个class C

{

void demo1(){}

}

那么A和B就能够继承C，这样就实现在代码的简化和复用。

Java语言中：java只支持单继承，不支持多继承。

因为多继承容易带来安全隐患:当多个父类中定义了相同功能，

当功能内容不同时，子类对象不确定要运行哪一个。

但是java保留这种机制。并用另一种体现形式来完成表示。多实现。

java支持多层继承。也就是一个继承体系

如何使用一个继承体系中的功能呢？

想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。通过了解共性功能，就可以知道该体系的基本功能。

那么这个体系已经可以基本使用了。

那么在具体调用时，要创建最子类的对象，为什么呢？

一是因为有可能父类不能创建对象，

二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

简单一句话：查阅父类功能，创建子类对象使用功能。

聚集：has a

事物与事物的另一种关系，比如（类与类，对象与对象）

聚合:例如：一个班里的有很多学生，那么班级和学生就是聚合关系。就是包含。

组合：组合与聚合区别在于，组合各成员是不可分割的，否则会缺少功能，但聚合里的成员可以脱离，对整体没有影响。

子父类出现后，类成员的特点：

类中成员：

1，变量。

2，函数。

3，构造函数。

1,变量

如果子类中出现非私有的同名成员变量时，

子类要访问本类中的变量，用this

子类要访问父类中的同名变量，用super。

super的使用和this的使用几乎一致。

this代表的是本类对象的引用。

super代表的是父类对象的引用。

例如：

class Fu

{

int num = 4;

}

class Zi extends Fu

{

int num = 5;

void show()

{

System.out.println(super.num);

//有super对象调用函数打印结果是4，没有打印结果是5

}

}

子父类中的函数另一个特性：函数的重写(覆盖)

当子类继承父类，沿袭了父类的功能，这时不但可以保留父类的功能定义，还可以重写功能内容。

覆盖要注意的关健点：

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

（权限修饰符没设的时候为默认权限，介于public与private之间。）

例如：

class Fu

{

void show()

{

System.out.println("fu show");

}

}

class Zi extends Fu

{

void show()

{

System.out.println("java");

//这里我即可以改变，也可以增加。增加时我们不用重写一遍父类函数的内容，只虽要super.函数名（）就可以。

}

2，静态只能覆盖静态。

注意：

重载：只看同名函数的参数列表。

重写：子父类方法要一模一样。

子父类中的构造函数之特点：

子类中的构造函数会默认调用父类中的函数中的默认构造函数，因为子类的构造函数默认第一行有一条隐式的语句super();

但有几个地方要注意：

例：

class Fu

{

Fu()

注意：如果没有这一个空参数的构造函数，但又有我们指认的非空参数的构造函数，那么我们知道默认那个空参数构造函数也不会生成，这个时候子类就会编译失败。这个时候就不能让子类默认获取super（）；而要指认super（x）

{

num= 60;

System.out.println("fu run");

}

Fu(int x)

{

System.out.println("fu ...."+x);

}

}

class Zi extends Fu

{

Zi()

{

super(); //不管父类有几个构造函数，只要没有指认，那么就默认这一个super();

//super(4);

System.out.println("zi run");

}

Zi(int x)

{

super();

super(3);

System.out.println("zi..."+x);

}

}

调用构造函数用super（）；（括号里面是参数），而调用一般函数用super.函数名（）

一个构造函数中只能要么有this要么有super，而且必须放在第一行

子类中至少会有一个构造函数会访问父类中的构造函数。

extends Object：java中的顶极父类，也就是任何没标明父类的类的默认父类。final : “最终”修饰符：

1，可以修饰类，函数，变量。

2，被final修饰的类不可以被继承。作用：为了避免被继承，被子类复写功能。3，被final修饰的方法不可以被复写。

4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。

当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。

而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过_连接。

5，内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。例如：

final int x=4；那么x永远等于4，不可以被赋值，就成了常量，之所以不直接定常量，是因为要给数值起个名，增强阅读性，以后也好调用。

抽象

修饰符，abstract：只能修饰类和方法：

特点：

1，修饰的类不能创建对象（实例）。

2，修饰的对象只有功能，没有内容。

3，抽象方法和抽象类都必须被abstract关键字修饰，也就是抽象方法一定在抽象类中，

但抽象类不一定要有抽象方法.

4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。

如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。因为抽象方法和抽象类都必须被abstract关键字修饰（如果只复写了一个，那么子类必然还继承了其它的抽象方法，根据抽象方法必须在抽象类中，则这个类还是个抽象类）。

应用：

1，建立不可创建对象的类。

2，如果子类中需要的方法内容不一样，但又同样都要这么方法，那么就可以创建一个抽象类。

例如：创建一个学校成员，有学生，有老师，都有姓名，年龄，都要上课，但老师上课是教学，学生上课是学习。所以可以这样写：

class XueXiao

{

private String name;

private int age；

XueXiao(String name,int age)

{

https://www.wendangku.net/doc/d72789144.html, = name;

this.age = age;

}

public abstract void work();//子类需要这个功能，但内容不一样，所以用抽象。}

class Student extends Employee

{

Student(String name,int age)

{

super(name,age);//直接调用父类构造函数。

}

public void work()

{

System.out.println("shangke");

}

}

class LaoShi extends Employee

{

LaoShi(String name,int age)

{

super(name,age);//直接调用父类构造函数。

}

public void work()

{

System.out.println("laoshi");

}

}

模版方法设计模式：

什么是模版方法呢？

在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，

那么这时就将不确定的部分暴露出去。由该类的子类去完成。

abstract class GetTime

{

public final void getTime()//这个类是不需要改变的，所以就用final最终修饰。

{

long start = System.currentTimeMillis();

runcode();

long end = System.currentTimeMillis();

System.out.println("毫秒："+(end-start));

}

public abstract void runcode();//这个函数主体要设成不确定，这样记算任何函数的运行时间：我只要把要算的函数定义成这个的内容就行了。所以设成抽象类的方法。

}

class SubTime extends GetTime

{

public void runcode()

{

for(int x=0; x<4000; x++)

{

System.out.print(x);

}

}

}

要调用计时这个功能，我们就在要在类中新健一个SubTime的对象。再调用getTime函数的就可以（SubTime类继承了父类，所以有getTime函数。）

接口：

接口：初期理解，可以认为是一个特殊的抽象类

当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。class用于定义类

关健字：interface 用于定义接口。

接口定义时，格式特点：

1，接口中常见定义：常量，抽象方法。

2，接口中的成员都有固定修饰符，（不写也会自动生成）。

常量：public static final

方法：public abstract

记住：接口中的成员都是public的。

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。原因和抽象类一样，有抽象则为抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。1，类可以实现多个接口，用关健字：implements 如：

class Test implements JieKou,JieKou2

2，类继承后，仍可以实现多个接口，如：

class Test extends Demo implements JieKou,JieKou2

3，接口在可以实现多继承,如：

interface Test extends A,B

例：

abstract class Student

{

abstract void study();学生都要学习，所以可以作为父类来给子类继承。

}

interface Smoking

{

void smoke();//抽烟不是所有学生都会，所以，不可以继承，不然所有学生都抽烟了，所以定义为接口，让需要的类实现就行。

}

class ZhangSan extends Student implements Smoking

//继承后再实现，这样就实现了功能的扩展。

{

void study(){}

public void smoke(){}//记得要复写,因为父类是抽象的。

}

class Lisi extends Student

{

void study()

{

System.out.prtintln("study")

}

}

多态：

1，多态的体现

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

父类的引用也可以接收自己的子类对象。

2，多态的前提

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

通常还有一个前提：存在覆盖。

3，多态的好处

多态的出现大大的提高程序的扩展性。

4，多态的弊端：

提高了扩展性，但是只能使用父类的引用访问父类中的成员。

如何要访问子类特有对象必须强制转换为子类对象。

abstract class Animal

{

abstract void eat();

}

class Cat extends Animal

{

public void eat()

多态还有一个前提：存在覆盖。不然没有意义，只是继承了一个空方法。

{

System.out.println("吃鱼");

}

public void catchMouse()

但是只能使用父类的引用访问父类中的成员。因为父类中并没有catchMouse方法，所以多态无法实现catchMouse

{

System.out.println("抓老鼠");

}

}

class Dog extends Animal

{

public void eat()

{

System.out.println("吃骨头");

}

}

public static void function(Animal a)//Animal a = new Cat();父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。

前题：必须是类与类之间有关系。要么继承，要么实现。Animal是动物，Cat 是它的子类。

{

a.eat();

}

class DuoTaiDemo

{

public static void main(String[] args)

{

function(new Cat());

function(new Dog());提高了扩展性，不用再去新建一个对象，再引用对象的功能。

}

Object类:

是所有对象的直接后者间接父类.

该类中定义的是所有对象都具备的功能。

如果自定义类中需要的功能是Object含有的，那么没有必要重新定义，只要沿袭父类中的功能，建立自己特有比较内容，覆盖即可。

常用的有比较功能：

public boolean equals(Object obj)

//这里要是Object对象，所以这里相当于：Object obj =new 自定义类（）

｛

......这里写其自定义的内容，如果这里要有自定义类里的特有功能，那么要强转对象

格式是：自定义类x = （自定义类）obj；

｝

内部类

特点：1，内部类可以直接访问外部类中的成员，包括私有。

（原因：内部类中持有了一个外部类的引用，格式：外部类名.this）

2，外部类要访问内部类，必须建立内部类对象。

3, 当内部类在成员位置上，就可以被成员修饰符所修饰。

比如，private：将内部类在外部类中进行封装。

static:内部类就具备static的特性。

当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中，新建立一个对象直接访问static内部类的非静态成员，但对象前

用外类名修饰

new Outer.Inner().function()

在外部其他类中，直接用类名来直接访问static内部类的静态成员，但类名前用外

类修饰

Outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。

当外部类中的静态方法访问内部类时，内部类也必须是static的。

何时应用内部类：

当描述事物时，事物的内部还有事物，该事物用内部类来描述。这个主要体现一种类的优化思想。而且一般将内部类私有，而通过创建方法给外部调用。

例如：

class Outer

{

private int x = 3;要访问这个是：Outer.this.x

class Inner//内部类

{

int x = 4;;//要访问这个是：this.x

void function()

{

int x = 6;;//如果不修饰则默认访问方法内的成员。

System.out.println("innner :"+Outer.this.x);

}

}

void method()外部类要访问内部类成员就要新建一个内部类对象。

{

Inner in = new Inner();

in.function();

}

}

class InnerClassDemo

public static void main(String[] args)

{

Outer out = new Outer();//

out.method();

//直接访问内部类中的成员就必须修饰引用。以下是格式：

外部类名.内部类名变量名= 外部类对象.内部类对象;

// Outer.Inner in = new Outer().new Inner();

// in.function();

}

}

当内部类定义在局部时：

1，不可以被成员修饰符修饰

2，可以直接访问外部类中的成员，因为还持有外部类中的引用。

但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。例如：

class Outer

{

void method(final int a)

{

final int y = 4;

class Inner

{

void function()

{

System.out.println(y);

}

}

new Inner().function();

}

}

class InnerClassDemo3

{

public static void main(String[] args)

{

Outer out = new Outer();

out.method(7);

out.method(8);

//注意：这里之所以可以，是因为out.method(7);进的是栈内存，用完后就自动消失了，out.method(8);又重新加载了，所以尽管变量被final修饰但是依然可以。

}

}

2.Java面向对象知识测试(答案版)解析

面向对象部分测试题 考试宣言: 同学们, 考试考多少分不是我们的目的! 排在班级多少的名次也不是我们的初衷! 我们考试的目的是要通过考试中的题目,检查大家在这段时间的学习中,是否已经把需要掌握的知识掌握住了,如果哪道题目你不会做,又或者做错了, 那么不用怕, 考完试后, 导师讲解的时候你要注意听! 那时候学会了, 记住了, 也一样不影响你高薪就业! 本套题共40道不定项选择题，其中单选30道，多选10道。单选2分/题，多选4分/题。多选题不全对半分，全对满分。 1.下面描述函数重写错误的是(c) A. 要有子类继承或实现 B. 子类方法的权限必须大于等于父类的权限 C. 父类中被private权限修饰的方法可以被子类重写 D. 子类重写接口中的抽象方法,子类的方法权限必须是public的 2.下列说法哪个正确？（a b c） A. 一个程序可以包含多个源文件 B. 一个源文件中只能有一个公共类 C. 一个源文件中可以有多个类 D. 一个源文件只能供一个程序使用

3.下面关于类的设计思路描述错误的是 ( b c ) A. 根据需求写出类所包含的字段(成员变量) B. 根据面向对象的思想要求，所有的字段都必须私有化 C. 封装之后的字段在本类内也必须使用get/set方法 D. 按需求可添加若干构造方法 4.关于封装下面介绍错误的是（d ）。 A. 封装将变化隔离 B. 封装提高重用性。 C. 封装提高安全性 D. 只有被private修饰才叫做封装 5.试图编译运行下面的代码会发生什么情况 (d) public class MyClass{ static int i; public static void main(String[] args){ System.out.println(i); } } A. 错误，变量i没有被初始化 B. 输出null C. 输出1 D. 输出0 6.下面对static的描述错误的是 b A. 静态修饰的成员变量和成员方法随着类的加载而加载 B. 静态修饰的成员方法可以访问非静态成员变量 C. 静态修饰的成员可以被整个类对象所共享

java面向对象精华总结教学文案

j a v a面向对象精华总 结

Java面向对象精华总结 面向对象是相对面向过程而言的，面向过程强调的是功能行为，面向对象是将功能封装进对象，强调具备了功能的对象。 面试官若问什么是面向对象（开放式问题，回答必须有自己的体会）： 1、面向对象是一种思想，可以使复杂的问题简单化，可以使我们从执行者变成 指挥者 2、结合实际场景举个例子说明：面试官就是在用面向对象的思想思考问题，公 司里面现在有招人的需求，说明公司现在的业务量比较大，代表着公司在蓬勃发展，你需要找一些具有专业编程经验的人来帮你完成公司的工作，我就是那个对象，我具备专业编程的功能，你就是在指挥我做事情，就是使用我的功能，来为公司创造效益。【万物皆对象】 面向对象三大特征：封装、继承、多态 类和对象的关系： 类：对现实生活中事物的描述 对象：就是这类事物，实实在在存在个体 描述事物就是描述事物的属性（对应类中变量）和行为（对应类中方法），属性和行为共同称为类的成员（成员变量和成员方法） 成员变量作用于整个类中，局部变量作用于函数中，或者语句中 成员变量在堆内存中，因为对象的存在，才在内存中存在，局部变量：存在栈内存中 封装（Encapsulation）：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式

好处：将变化隔离、便于使用、提高重用性、提高安全性 封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问 private（私有）：权限修饰符，用于修饰类中的成员（成员变量，成员函数），私有只在本类中有效。 static用于修饰成员（成员变量和成员函数） 被修饰的成员：随着类的加载而加载，优先于对象存在，被所有对象所共享，可以直接被类名调用。类名.静态成员【方法区、共享区、数据区】----存放类中的方法和共享数据。 什么时候定义静态函数：当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的，用类名直接调用。 Eg：获取数组的最大值 class ArrayTool { public static void main(String[] args) { int[] arr={5,8,4,1,3,5,8,77,55,99}; int max=GetMax.getMax(arr); System.out.println("max="+max); } } class GetMax { public static int getMax(int[] arr) { int max=0; for(int x=0;xarr[max]) max=x; } return arr[max];

实验三Java面向对象高级编程

实验三Java面向对象高级编程 一、实验目的 1. 掌握Java 面向对象编程技术 2. 能够使用继承创建子类并实现方法覆盖 3. 能够创建异类集合并使用多态 4. 能够创建抽象类和接口，并探究它们的多态特性 二、预备知识 1. JDK的安装设置：JDK/JRE/JVM； 2. Eclipse集成开发环境的绿色安装； 3. 掌握Java语言的面向对象特性（封装性、继承性、多态性）； 4. 掌握Java语言的抽象类和接口。 三、实验描述 1. 实验类型：设计 2. 实验学时：4学时 3. 实验容：2项（参照四） 四、实验容 (1) 检查所使用的计算机系统： 1. 确认是否已安装JDK，并确认系统的环境变量设置； 2. 确认是否已绿色安装Eclipse集成开发环境。 (2) 实验容一：使用继承和方法覆盖创建子类，并能够创建异类集合并使用多态 具体要求： 1. 在上述银行项目中，创建Customer类： ·位于包：.mybank.domain中； ·向Customer类添加四个实例变量：firstName，lastName，accounts（Account 对象数组，长度为10）和numberOfAccounts（记录accounts数组索引的一个整数）； ·添加一个公有构造方法：两个形式参数firstName，lastname，用于初始化客户、创建accounts数组和初始化accounts数组元素个数numberOfAccounts； ·添加getFirstName方法：该方法返回客户的firstName实例变量； ·添加getLastName方法：该方法返回客户的lastName实例变量； ·添加addAccount方法：该方法有一个形式参数（即Account对象），数组的下标通过实例变量numberOfAccounts实现递增，同时将该参数对象存储在accounts 数组中； ·添加getNumberOfAccounts方法：该方法返回numberOfAccounts实例变量； ·添加getAccount方法：该方法返回与指定的index数组下标相关的对象。 2. 创建SavingsAccount类，该类是Account类的子类： ·位于包：.mybank.domain中； ·向SavingsAccount类中添加interestRate实例变量； ·添加一个有两个参数的公有构造方法：initBalance和interestRate。调用父类构造

java的心得体会[工作范文]

java的心得体会 篇一：java初学者学习心得 学习Java心得体会 学习了一学期的Java课程,觉得是该总结自己的心得体会了。开始学习任何一门课，兴趣最重要。一直觉得自己在学计算机编程语言，学习了很多，但每门语言都停留在知识边缘地带，都没深入到它们的精华部分，对它们的精华部分知之甚少，于是趁学校开设这门课，并且有自己的老师讲解，还有了上机的机会，比自己自学省事多了，于是鼓足信心，开始了漫长的java征途。 还记得我编写的第一个经典程序“hello Word”。从那时起我已开始走进Java的世界。当时自己不是很理解为什么main方法一定要这样来定义public static void main，能不能不这样写？问了好多同学，他们告诉我的答案是一样的“java本身要求就是这样子的”，但我自己不甘心，就进行了下面的好多操作：把main改个名字运行一下，看看报什么错误，然后根据出错信息进行分析；把main的public 取掉，在试试看，报什么错误；static去掉还能不能运行；不知道main方法是否一定要传一个String[]数组的，把String[]改掉，改成int[]，或者String试试看；不知道是否必须写args参数名称的，也可以把args改成别的名字，

看看运行结果如何。结果把Hello World程序反复改了七八次，不断运行，分析运行结果，最后就彻底明白为什么了main方法是这样定义的了。接着在以后的学习中我也采用这样的方法解决问题，却发现自己的速度比别人慢了好多，我就把自己的课余时间也分一部分给了java。 因为基础是最重要的，只有基础牢固才有可能对后面的学习有更加深刻的认识！ 学习一门新的语言，参考书是离不开的。听老师说订的教材偏难，不适合我们初学者，于是我在图书馆借了参考书（一本篇幅较短的入门书来学习那些最简单、最基本的东西，包括学习Java语法等）。同时，对一个最简单的程序也应该多去调试，多想想如果改动一下会出现什么结果？为什么必须那样写？多去想想这些问题然后去操作，会让你有更多的收获。这样反复地思考是很有用的。 在学习Java的语法时，Java的语法是类似c语言的，所以学习的比较轻松。唯一需要注意的是有几个不容易搞清楚的关键字的用法，public，protected，private，static，什么时候用，为什么要用，怎么用，和同学一起讨论了好久才得以解决。 在学习Java的面向对象的编程语言的特性。比如继承，构造器，抽象类，接口，方法的多态，重载，覆盖，Java的异常处理机制。对于一个没有面向对象语言背景的人来说，

面向对象技术Java 期末复习试卷(三)

期末复习试卷（三） 一、单项选择题 1、有一段java应用程序，其中包含一个公共类，名字为TestStudent，那么保存它的源 文件名是（） A. teststudent.java B. teststudent .class C. TestStudent.java D. TestStudent.class 正确答案：C 解析：一个java文件中可以包含多个类，但最多只能有一个类是公共类（public），该java文件的名字要与公共类的一致。 2、关于下面的代码，哪个描述是正确的？ public class Test{ public static void main(String[] args){ Integer n1 = new Integer(3); Object n2 = new Integer(4); System.out.println(https://www.wendangku.net/doc/d72789144.html,pareTo(n2)); } } A. 可以编译通过，可以运行，并得到预期结果。 B. 可以编译通过，可以运行，但不能得到预期结果。 C. 可以编译通过，但又运行错误。 D. 有编译错误。 正确答案：D 解析：Integer类是基本数据类型int的包装类，里面封装了一个int类型的值，

提供了一些实用的方法（例如：在JavaFX中读取文本框内容是String类型的，如果要转换成int类型，就要调用Integer类的parseInt()方法）并实现了Comparable接口，在Comparable接口中定了抽象方法compareTo(T o), T是泛型，对于Integer类，T 被替换为Integer，如下图： 因此，Integer类中compareTo()方法的定义如下： 因此，compareTo的参数只能是Integer类型的，所以代码中的下面语句中的n2的类型需要进行强制类型转换，由Object转为Integer： System.out.println(https://www.wendangku.net/doc/d72789144.html,pareTo(n2)); 正确写法如下： System.out.println(https://www.wendangku.net/doc/d72789144.html,pareTo((Integer) n2)); 类似的包装类还有Long\Float\Double\Char\Boolean等，都是将基本数据类型包装为类。 3、下面哪种类型不是引用数据类型？（） A. 数组 B. char C. String D. Object 正确答案：B 解析：基本数据类型只是存放数据，不提供功能（即方法）包括4类八种： 布尔类型：boolean

java面向对象知识点总结

j a v a面向对象知识点总 结 Company Document number：WTUT-WT88Y-W8BBGB-BWYTT-19998

1 类和对象 类: 类是用来描述一类事物的共性内容的, 类是抽象的; 创建类,如何描述 属性功能 用变量来描述属性 用方法来描述功能 对象: 就是现实中具体的事物,对象是具体的; 创建对象 类名对象名 = new 类名(); 如何通过对象访问类中属性和方法呢 对象名.变量名 对象名.方法名(); 只要是new的对象,就是新创建的,就会在内存中开辟一段单独的空间匿名对象 创建的对象没有赋值给具体的变量; 所以给匿名对象的属性赋值是没有任何意义的; 匿名对象使用场景

1 调用方法 2 作为参数传递 3 添加进容器中 This 关键字 This. 类中的普通方法访问到的成员前边都有this.这个关键字This. 就代表当前对象, 普通方法, 创建对象调方法, 谁调用就代表谁 This(); 可以用来在构造函数中调用本类与之相对应的构造函数使用注意事项: 1 this() 只能是构造函数的第一条执行语句 2 this() 不能在构造函数之间相互调用 3 this() 不能调用自己 构造函数(方法) 构造函数的作用 用来给对象进行初始话的(初始化就是指给对象的各个属性赋值) 构造函数何时执行 对象一创建就会调用与之相对应的构造函数

构造函数语法 修饰符没有返回值类型类名(参数列表){ 具体执行的代码 } 构造函数自动添加 当一个类中我们没有明确指定构造函数的话,jvm会自动帮我们添加一个空参数的构造, 如果我们指定了,就不添加了 构造函数和普通函数的区别 执行时机不同 对象一创建就会调用与之相对应的构造函数 普通函数只有被调用才会执行 return 1 就是用来在方法中返回具体结果(结果类型必须和方法的返回值类型一致) 2 即便方法的返回值类型是void,方法中也可以出现 return; 3 构造函数中也可以有return关键字 成员变量和局部变量 1 作用范围不同, 成员变量是定义在类中的,在整个类中都起作用 局部变量是定义在方法中的,在所在代码块起作用

完成Java面向对象程序设计实验课的心得体会范文

Java面向对象程序设计实验课的心得体会经过这几周对Java面向对象程序设计的学习，让我更加了解到Java学习的重要性。 在实验课上，我们完成多个实验，在这个阶段的学习中，我从认识到熟悉，而后到能够自主运用。通过对Java的了解，我发现它确实有很多方便之处，它集抽象性、封装性、继承性和多态性于一体，实现了代码重用和代码扩充，提高了软件开发的效率。对于我们这个专业来说学好Java语言是很重要的，所以在实验的过程中我都尽力理解java编程思想、掌握基本技巧，尽量学到最多的知识。 学习程序设计的基本目的就是培养描述实际问题的程序化解决方案的关键技能，Java面向对象程序设计是一门实践性比较强的课程，在实际中，我们必须把理论和实践结合起来。在实验中，我们理解理论课上的知识，然后运用到实际的操作中，我们必须在现有的理论的基础上，进行实践。多次实验后，也让我看到了现在学习的一个很大弱点：只听不练，永远不会熟练运用；空记技巧，忽略思想，会在多变的习题中十分无奈。 Java思想：Java是一门面向对向语言，他定义一切都是对象面向对象，就是面对现实； 现实中的一切都是对象，他们有分类，就产生了“类”； 他们有不同，类和类之间的不同，使用类来区分； 同一个类中不同的对象的区别，使用成员区分。

所以，面向对象的内部逻辑是分类。 面向对象编程思想就象数学上的一些概念，如：空间、群、环、域等 原始的编程思想就象古典数学，人们只在一个集合上探讨问题，没有系统的方法（即运算）定义，于是仁者见仁、智者见智，这样在一定程度上造成了理论的一种混乱局面，不利于科学的发展。于是近代数学向公理化发展，这是什么意思呢？就是说，人们除了在限定论域（即上面的集合，面向对象也有此概念）外，还在此论域上加进了一套通用的、公认的运算（方法）；集合加上集合上定义的运算就构成了数学上的空间、群等，在计算机领域里，就变成为“类”。这种集合上定义了操作的东西利用起来就方便多了，这使得人们讨论问题时都在给定集合的运算能力上下工夫，即有通用性可事半功倍。 面向对象的编程思想就要想近世代数的分析思想，首先要确定“论域”，即工程所涉及到的所有的“对象”，然后要分类处理，把隶属同一类别的对象集合在一起（做成一个集合），定义他们之间的运算性质及可以进行的操作，这样就构建了一个类，当然以后用到这个类的对象时都要通过已经定义了的操作来完成各项功能，这就是常要求的类的“类的成员变量要通过共有函数来操作”。 我想真正的面向对象编程思想不应该是编程思想，应该是面向对象的分析方法才对！ 我的理解： 1、将分析过程为抽象的过程：简言之：分成多个小问题（组成部分），

java面向对象试卷及答案

java面向对象程序设计 系班级姓名成绩得分评卷人 一、填空题（每空2分，共20分） 1．Java源程序的扩展名是，经过编译后的程序的扩展名是。2．Socket通常也称为，用于描述和。3．线程的优先级在至之间，数值越大 4．构造方法是一种特殊的成员方法，构造方法名与相同 5．Java语言只允许单继承，指每个类只能有一个。 二、选择题（每题2分，共50分） 1．下列哪个概念是面向对象和面向过程程序设计所共有的（） A、继承 B、流程控制 C、抽象 D、封装 2．以下关于执行Java小程序的论述错误的是：（） A、可以通过浏览器调用嵌入了Java小程序的HTML文档 B、可以通过appletviewer.exe调用嵌入了Java小程序的HTML文档 C、可以通过java.exe调用嵌入了Java小程序的HTML文档 D、可以在Java集成开发环境中调用嵌入了Java小程序HTML文档 3．符合对象和类关系的是：（） A、人和老虎 B、书和汽车 C、楼和土地 D、松树和植物 4．关于选择结构下列哪个说法正确？（） A．if语句和else语句必须成对出现 B．if语句可以没有else语句对应 C．一个if语句只能有一个else if语句与之对应 D．else if结构中必须有default语句 5．while循环和do…while循环的区别是：（）

A．没有区别，这两个结构任何情况下效果一样 B．while循环比do…while循环执行效率高 C．do…while循环执行次数可能为0 D．while循环执行次数可能为0 6．关于for循环和while循环的说法哪个正确？（） A．while循环先判断后执行，for循环先执行后判断。 B．while循环判断条件一般是程序结果，for循环的判断条件一般是非程序结果C．两种循环任何时候都不可以替换 D．两种循环结构中都必须有循环体，循环体不能为空 7．下列修饰符中与访问控制无关的是（） A．private B．public C．protected D．final 8．方法内的形参：（） A．必须定义多个形参B．可以没有 C．至少有一个D．只能是简单变量 9．throws的作用：（） A．表示方法可能会抛出例外 B．表示后面是方法的输出量 C．方法的标志，每个方法都必须有 D.没有意义 10．在Java语言中，整型常量123占用的存储字节数是：（）A．1B．2 C．4 D．8 11．关于对象成员占用内存的说法哪个正确？（） A．同一个类的对象共用同一段内存 B、同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间C．对象的方法不占用内存 D．以上都不对 12．return语句：（）

java面向对象精华总结

Java面向对象精华总结 面向对象是相对面向过程而言的，面向过程强调的是功能行为，面向对象是将功能封装进对象，强调具备了功能的对象。 面试官若问什么是面向对象（开放式问题，回答必须有自己的体会）： 1、面向对象是一种思想，可以使复杂的问题简单化，可以使我们从执行者变成指挥者 2、结合实际场景举个例子说明：面试官就是在用面向对象的思想思考问题，公司里面现在 有招人的需求，说明公司现在的业务量比较大，代表着公司在蓬勃发展，你需要找一些具有专业编程经验的人来帮你完成公司的工作，我就是那个对象，我具备专业编程的功能，你就是在指挥我做事情，就是使用我的功能，来为公司创造效益。【万物皆对象】面向对象三大特征：封装、继承、多态 类和对象的关系： 类：对现实生活中事物的描述 对象：就是这类事物，实实在在存在个体 描述事物就是描述事物的属性（对应类中变量）和行为（对应类中方法），属性和行为共同称为类的成员（成员变量和成员方法） 成员变量作用于整个类中，局部变量作用于函数中，或者语句中 成员变量在堆内存中，因为对象的存在，才在内存中存在，局部变量：存在栈内存中 封装（Encapsulation）：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式 好处：将变化隔离、便于使用、提高重用性、提高安全性 封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问private（私有）：权限修饰符，用于修饰类中的成员（成员变量，成员函数），私有只在本类中有效。 static用于修饰成员（成员变量和成员函数） 被修饰的成员：随着类的加载而加载，优先于对象存在，被所有对象所共享，可以直接被类名调用。类名.静态成员【方法区、共享区、数据区】----存放类中的方法和共享数据。什么时候定义静态函数：当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的，用类名直接调用。 Eg：获取数组的最大值 class ArrayTool { public static void main(String[] args) { int[] arr={5,8,4,1,3,5,8,77,55,99}; int max=GetMax.getMax(arr); System.out.println("max="+max); } } class GetMax { public static int getMax(int[] arr) { int max=0; for(int x=0;x

Java心得体会

Java学习心得 在学习了近一个学期java后，我有了一点自己的见解。Java是面向对象的，具有平台无关性。所以现在被广泛的应用于很多领域。也是因为老师在开始上课的时候就给我们讲过这些，所以带有兴趣和动力去学习java程序设计。 在开始学习java时，觉得有c语言做基础会比较容易一些。Java 区分大小写，在一开始调试别人的程序时，常会因为字母、空格等一些小的失误调试不出来，慢慢地随着练习的增多，这些低级错误也渐渐可以避免了。Java中类比较多，还有包等，一开始学起来觉得比较繁琐。 通过学习，对java有了一定的了解。Java的运行原理：Java是一门编译解释型语言，我们写好的Java程序经过编译后生成后缀名为class的文件，在经过Java虚拟机JVM对class文件进行解释运行，Java 程序才能运行起来。（需要JVM是它实现跨平台的关键，所以又说Java 是跨平台语言）。Java思想：Java是一门面向对向语言，他定义一切都是对象，例如小程序： 里边定义了两个类NewClass 和Student NewClass调用了Student 的add()方法。 课堂上老师根据课本讲的内容都是基础的，要想有进一步的提高，需要课下花时间去求助网络等方法。因为之前我没有太大的兴趣和充足的时间，所以只是学习课本基础知识。后来我从网络上学习了一些

关于java程序汇编的一些思想，有助于以后深入系统的学习。 具体而言，学习java其实就是学习程序设计，学习程序设计就需要接受一种编程思想。要掌握java的精华特性而且要知道是什么，比如，Interface和multi-thread。用interface是更好的多继承的模型，而多线程则是设计到语言一级的重要特性。要完全理解interface是为什么，用多线程又有几种常用的编程模型。学习语言是要应用的，所以在掌握基本的思想后要转化为应用。目前比较好的开发模式是采用自定向下的面向对象的设计，加上MVC的模式（MVC架构是"Model-View-Controller"的缩写，中文翻译为"模型-视图-控制器"。MVC 应用程序总是由这三个部分组成。Event(事件)导致Controller改变Model或View，或者同时改变两者。）。首先要找出最顶层的对象（这往往是最难的），然后一层一层往下递归，记住每次应符合7+/-2的原则，因为我们人的短记忆就是这样。一般有图形用户界面的应从界面开始设计。在有了初步的设计模型之后，为了更好的设计程序，应该学习一下设计模式，例如体系结构模式（Layering分层，Pipe/Filter 管道或过滤器）、编程模式（比如Copy-on-Write）。懂了这些模式之后，就会对系统的整体结构有很好的把握，而学术上也有倾向一个系统完全可以由各种模式组合而成。对于程序设计，在初步对基本程序进行调试后，应该将纸上谈兵转化成实践。一般课本上的例子不能算是实践，只能知道一些语言特性的应用，而对于实际的工程来讲仅是冰山一角。对于像我们这样的初学者，应该在公认的论坛里面找一些比较经典的例子。比如用Java实现的HotDraw（源自SmallTalk），在

2012-2013java面向对象期末测试题(带答案)

济南大学2009～2010 学年第二学期课程考试试卷 课 程 java 面向对象程序设计 授课教师 考试时间 考试班级 学 号 姓 名 题号 一 二 三 四 五 总 分 审核人 得分 一、填空题（每空2分，共20分） 1．Java 源程序的扩展名是 .java ，经过编译后的程序的扩展名是 .class 。 2．Socket 通常也称为 套接字 ，用于描述 IP 地址 和 端口 。3．线程的优先级在 1 至 10 之间，数值越大 优先级越高 4．构造方法是一种特殊的成员方法，构造方法名与 类名 相同 5．Java 语言只允许单继承，指每个类只能有一个 父类或子类 。 二、选择题（每题2分，共50分） 1．下列哪个概念是面向对象和面向过程程序设计所共有的 （ B ） A 、继承 B 、流程控制 C 、抽象 D 、封装 2．以下关于执行Java 小程序的论述错误的是： （ C ） A 、可以通过浏览器调用嵌入了Java 小程序的HTML 文档 B 、可以通过appletviewer .exe 调用嵌入了Java 小程序的HTML 文档 C 、可以通过java.exe 调用嵌入了Java 小程序的HTML 文档 D 、可以在Java 集成开发环境中调用嵌入了Java 小程序HTML 文档 3．符合对象和类关系的是： （ D ） A 、人和老虎 B 、书和汽车 C 、楼和土地 D 、松树和植物 4．关于选择结构下列哪个说法正确？ （B ） A ．if 语句和 else 语句必须成对出现 B ．if 语句可以没有else 语句对应 … … …… …… …… …… …… … …… …装 …… …… …… … …… …订 …… …… …… … …… …线 …… …… …… … …… …… …… …… …

面向对象技术(Java)-实验2-类与对象

实验报告 课程名称面向对象技术（Java）实验项目类和对象 实验仪器个人计算机 学院计算机学院 专业计算机大类 班级/学号 学生姓名___ ___________ 实验日期2019/04/03 指导教师___ _________

实验项目二类和对象 一、实验目标 1．掌握类的定义和对象的创建以及使用方法；掌握UML类图的绘制。 2．掌握实例变量与静态变量、实例方法与静态方法的区别与使用。 3．掌握成员变量与局部变量的定义与使用。 4．理解和掌握面向对象技术的封装性，能够运用面向对象思想、术语和相关技术正确表达一般工程问题。 二、实验要求 1.上机实验前，按照每一个实验题目的具体要求提前完成准备工作，如：查找资料、设计 算法、写出全部源程序，做好预习笔记，做到有准备地上机。 2.上机实验课内，积极调试及修改程序。上传程序到过程化考核平台 /http://211.68.40.252:8008/ 3.上机实验课后，学生应根据实验数据及结果，完成实验报告。实验报告是评定实验成绩 的重要组成部分。完成的实验报告交给课代表，课代表收齐本班的实验报告后统一交指导教师审阅评定。 三、实验环境 硬件环境：个人电脑一台 软件环境：JDK1.8及以上版本，NetBeans8.0及以上版本 四、实验内容 任务1 、定义一个名为Circle的类表示圆形。这个Circle类包括： （1）一个名为radius的私有double型数据域，表示圆的半径。radius的默认值为1。（2）一个名为numberOfObjects的私有静态数据域，用于记录创建的圆对象的个数。（3）一个无参构造方法。 （4）一个能指定radius的构造方法。 （5）一个名为getArea()的方法返回这个圆形的面积。 （6）一个名为getNumberOfObjects的类静态方法，返回已创建圆的个数。 （7）radius的set/get方法。 然后，编写一个测试程序。要求在测试程序中： （1）创建一个半径为5.0的圆对象myCircle，并输出这个圆的半径及面积。 （2）修改这个圆的半径，将其半径扩大到1.1倍后，重新输出它的半径及面积。 解题要求：使用Math.PI，计算圆面积。 输出参考样例如图所示。

南京邮电大学java实验报告面向对象

实验报告班级：姓名：学号： 课程名称Java程序设计实验项目Java的面向对象编程 实验项目类型验 证 演 示 综 合 设 计 指导教师吴伟敏成绩√ 一、实验目的 1、掌握Java程序面向对象编程的基本架构； 2、掌握有关面向对象的基本概念，如：类、对象、接口继承和多态等； 3、掌握包程序设计的方法，了解大型软件的构造方式 二、实验步骤 1、录入并测试以下程序，说出此程序的作用，体会类和对象的关系。 程序如下： class CCircle { double pi; double radius; double getRadius(){ return radius; } void setCircle(double r, double p){

pi=p; radius=r; } } public class Ex2_1 { public static void main(String args[]) { CCircle cir1=new CCircle(); cir1.setCircle(2.0,3.1416); System.out.println("radius="+cir1.getRadius()); } } [基本要求] 运行程序并观察运行结果。 [思考问题] 试述程序中每条语句的作用。 2、录入并测试和完善以下程序，体会接口的用法。 interface Sittable{ void sit(); } interface Lie{ void sleep(); } interface HealthCare{ void massage(); }

class Chair implements Sittable{ public void sit(){ System.out.println("It is sittable!"); }; } class Sofa extends Chair implements Lie,HealthCare{ public void sleep(){ System.out.println("It is sleep!"); }; public void massage(){ System.out.println("give a message!"); }; public static void main(String[] args) { Sofa cottonSofa=new Sofa(); System.out.println(" Sofa is ok!"); } } [基本要求] 运行程序并观察运行结果。 [思考问题] 试述程序中每条语句的作用。

面向对象心得体会

面向对象心得体会 篇一：完成Java面向对象程序设计实验课的心得体会 Java面向对象程序设计实验课的心得体会经过这几周对Java面向对象程序设计的学习，让我更加了解到Java学习的重要性。 在实验课上，我们完成多个实验，在这个阶段的学习中，我从认识到熟悉，而后到能够自主运用。通过对Java的了解，我发现它确实有很多方便之处，它集抽象性、封装性、继承性和多态性于一体，实现了代码重用和代码扩充，提高了软件开发的效率。对于我们这个专业来说学好Java语言是很重要的，所以在实验的过程中我都尽力理解java编程思想、掌握基本技巧，尽量学到最多的知识。学习程序设计的基本目的就是培养描述实际问题的程序化解决方案的关键技能，Java面向对象程序设计是一门实践性比较强的课程，在实际中，我们必须把理论和实践结合起来。在实验中，我们理解理论课上的知识，然后运用到实际的操作中，我们必须在现有的理论的基础上，进行实践。多次实验后，也让我看到了现在学习的一个很大弱点：只听不练，永远不会熟练运用；空记技巧，忽略思想，会在多变的习题中十分无奈。 Java思想：Java是一门面向对向语言，他定义一切都是对象面向对象，就是面对现实；

现实中的一切都是对象，他们有分类，就产生了“类”；他们有不同，类和类之间的不同，使用类来区分；同一个类中不同的对象的区别，使用成员区分。 所以，面向对象的内部逻辑是分类。面向对象编程思想就象数学上的一些概念，如：空间、群、环、域等原始的编程思想就象古典数学，人们只在一个集合上探讨问题，没有系统的方法（即运算）定义，于是仁者见仁、智者见智，这样在一定程度上造成了理论的一种混乱局面，不利于科学的发展。于是近代数学向公理化发展，这是什么意思呢？就是说，人们除了在限定论域（即上面的集合，面向对象也有此概念）外，还在此论域上加进了一套通用的、公认的运算（方法）；集合加上集合上定义的运算就构成了数学上的空间、群等，在计算机领域里，就变成为“类”。这种集合上定义了操作的东西利用起来就方便多了，这使得人们讨论问题时都在给定集合的运算能力上下工夫，即有通用性可事半功倍。 面向对象的编程思想就要想近世代数的分析思想，首先要确定“论域”，即工程所涉及到的所有的“对象”，然后要分类处理，把隶属同一类别的对象集合在一起（做成一个集合），定义他们之间的运算性质及可以进行的操作，这样就构建了一个类，当然以后用到这个类的对象时都要通过已经定义了的操作来完成各项功能，这就是常要求的类的“类

面向对象技术Java-期末复习试卷(三)

期末复习试卷(三) 单项选择题 1、有一段java应用程序，其中包含一个公共类，名字为TestStudent,那么保存它的源 文件名是( ) A. teststudent.java B. teststudent .class C. TestStudent.java D. TestStudent.class 正确答案：C 解析：一个java 文件中可以包含多个类, 但最多只能有一个类是公共类 ( public ), 该java 文件的名字要与公共类的一致。 2、关于下面的代码,哪个描述是正确的？ public class Test{ public static void main(String[] args){ Integer n1 = new Integer(3); Object n2 = new Integer(4); System.out.println(https://www.wendangku.net/doc/d72789144.html,pareTo(n2)); } } A. 可以编译通过,可以运行,并得到预期结果。 B. 可以编译通过,可以运行,但不能得到预期结果。 C. 可以编译通过,但又运行错误。 D. 有编译错误。 正确答案：D 解析：Integer 类是基本数据类型int 的包装类,里面封装了一个int 类型的值, 提供了一些实用的方法 (例如：在JavaFX中读取文本框内容是String类型的，如果要转换成int类型，就要调用Integer类的parselnt() 方法)并实现了Comparable接口，在Comparable接口中定了抽象方法compareTo(T o), T 是泛型，对于Integer 类，T 被替换为Integer，如下图：

java课设心得体会.doc

java课设心得体会 篇一：Java培训课心得总结 lampbrotherJava培训课心得总结 在参加java培训的过程中，我感觉其实生活中很多时候与java编程是存在相似点。比如说我们想做一件什么事情，总是要先考虑下这件事的目的，做这件事需要先准备些什么，中间需要哪些步骤，最后怎样实现等等，这与计算机编程思想惊人的相似，所以说，在很多人看来，计算机很复杂，有数不清的代码和程序，可以完成各种各样的任务，功能千变万化，要掌握它是一件难比登天的任务，其实不然。计算机这种复杂性，完全是人赋予的，计算机只是单纯的按照人的指令去完成我们想要完成的事情，从这方面看，计算机是简单的。经过这一次的java培训，其中在java的各种对象、方法、类等方面上有了一个比较清晰的想法。当自学时你就不会听到 有这样那样的想法与指导，学起来就会比较迷茫点，但是有一个比较好的老师来指点下，那样的效果上就不同了，可以让自己的想法和思维开拓点来学习java，亲身感受过后，确实跟自学不一样，自学的话自己可能没这么好去理解代码，有个人带着去理解代码的话学起来比较快点，，用起来也会容易惯通点。 通过这次也可以学到一个团队的重要，一个小项目可以一个人完成，那已经是很痛苦地那种了，但是有一个大项目的话，那就不是一个人可以完成的事了，必须由一个团体来共同完成项目，一个的技术牛不算牛，一个团体的技术都很牛了那才是真正的牛，这样合作起来就可

以更快的把一个项目完成，而个人来说，也不会感到非常吃力，分功合作对于开发一个项目来说是重要的一步，在分功的时候必须分功明确，不然在开发程中会出现错乱，例如一个人开发了登陆的功能了，由于分功不明确导至另一个在也在开发此功能，分功明确了会减去诸如些类的一些错误和麻烦。 学习java听老师讲起课来，自己听得明白，但是要自己真的去动手起来做的话，那又是另一回事了，听得明白不一定就可以自己动手做出来，学习java只有听懂了再自己动手去真正的做出一些东西来运用这些代码，让代码在你脑子里转来转去不会忘记，看到有类似的功能你就会想起用这些代码来实现功能，那样才是真正的学会了，不然你就是没学会。在学习java的过程中，最需要的就是耐心，在学习过程中，你会感到很枯燥，烦恼，无聊，寂寞感，，但这些都不是问题，问题就是你能不能有很好的耐心学习下去，一般的人都是因为没耐心学下去才觉得它难，其实java语言本身不难，难的是你自己有没有这样的心去学，耐心很重要。耐心+灵活变通=学习成功 篇二：Java课程设计总结报告 闽南师范大学计算机学院 Java课程设计总结报告 篇三：完成Java面向对象程序设计实验课的心得体会 Java面向对象程序设计实验课的心得体会经过这几周对Java面向对象程序设计的学习，让我更加了解到Java学习的重要性。 在实验课上，我们完成多个实验，在这个阶段的学习中，我从认识到熟悉，而后到能够自主运用。通过对Java的了解，我发现它确实有很

Java语言与面向对象技术复习资料

一、单项选择题。 1、下列哪个是Java应用程序主类中正确的main方法？（） A．public void main(String args[]) B．static void main(String args[]) C．public static void Main(String args[]) D．public static void main(String args[]) 2、下列哪项是正确的float变量的声明？（） A．float foo=-1; B．float foo=1.0; C．float foo=2.02f; D．float foo=0x0123; 3、对于int a[]=new int[3];下列哪个叙述是错误的？（） A．a.length的值是3。B．a[1]的值是1。 C．a[0]的值是0。D．a[a.length-1]的值等于a[2]的值。 4、下列哪个叙述是正确的？（） A．5.0/2+10的结果是double型数据。 B．(int)5.8+1.0的结果是int型数据。 C．’苹’+’果’的结果是char型数据。 D．(short)10+’a’的结果是short型数据。 5、对于下列Hello类，哪个叙述是正确的？（） A．Hello类有2个构造方法。 B．Hello类的int Hello()方法是错误的方法。 C．Hello类没有构造方法。 D．Hello无法通过编译，因为其中的hello方法的方法头是错误的（没有类型）。 class Hello { Hello (int m) { } int Hello() { Return 20; } hello() { } } 6、下列哪个叙述是正确的？（） A．成员变量的名字不可以和局部变量的名字相同。 B．方法的参数的名字可以和方法中声明的局部变量的名字相同。 C．成员变量没有默认值。 D．局部变量没有默认值。 7、下列哪个叙述是正确的？（） A．子类继承父类的构造方法 B．abstract类的子类必须是非abstract类 C．子类继承的方法只能操作子类继承和隐藏的成员变量 D．子类重写或新增的方法也能直接操作被子类隐藏的成员变量 8、下列程序中注释的哪个代码（A，B，C，D）是错误的（无法通过编译）？（）class A {

java实训报告心得

java实训报告心得 一、实训项目 简易记事本 二、实训目的和要求 本次实训是对前面学过的所有面向对象的编程思想以及JAVA WEB 编程方法的一个总结、回顾和实践，所以，开始设计前学生一定要先回顾以前所学的内容，明确本次作业设计所要用到的技术点并到网上搜索以及查阅相关的书籍来搜集资料。通过编写采用 JSP+Servlet+JavaBean技术框架的应用系统综合实例，以掌握Java WEB开发技术。 具体要求有以下几点： 1. 问题的描述与程序将要实现的具体功能。 2. 程序功能实现的具体设计思路或框架，并检查流程设计。 3. 代码实现。 4. 设计小结。 三、实训项目的开发环境和所使用的技术 基于J2SE基础，利用MyEclipse 8.5以上版本的集成开发环境完成实训项目，界面友好，代码的可维护性好，有必要的注释和相对应的文档。 四、实训地点、日程、分组情况： 实训地点：4栋303机房 日程： 第一阶段：1.班级分组，选定课题，查阅相关资料半天

2.划分模块、小组成员分工半天 3.利用CASE工具实行系统设计和分析，并编制源程序 5天 第二阶段：上机调试，修改、调试、完善系统 2天 第三阶段：撰写、上交课程设计报告，上交课程设计作品源程序（每人1份）2天 五、程序分析 功能模块说明 弹出菜单 for(int f=0;f<4;f++) 改变字号： public void zihao() Font f=new Font("",Font.PLAIN,20); jta.setFont(f);} 设置字型 public void ziti() Font f=new Font("微软雅黑",Font.PLAIN,15); 改变字体颜色 public void Font() JColorChooser jColor=new JColorChooser(); Color fcolor=jta.getForeground(); jta.setForeground( jColor.showDialog(jta,"选择字体颜色",fcolor)); }