面向对象概述并举例说明 面向过程 强调过程，执行者，强调的是功能行为 面向对象 强调对象，指挥者，将功能封装进对象，强调具备了功能的对象。 面向对象举例 煎饼果子 面向对象思想的特点 A：它是一种更符合人们思考习惯的思想
B：它使复杂的内容简单化
C：它使我们从执行者变成了指挥者 面向对象的特点 A：封装 B：继承 C：多态 开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。 类和对象的关系 使用计算机语言就是不断的在描述现实生活中的事物。
java中描述事物通过类的形式体现，类是一组相同属性行为的对象的抽象。
对象即是该类事物实实在在存在的个体。 举例: 人就是一个类(是把每一个相同属性行为的对象进行抽取) 人的属性:姓名,年龄,身高,体重等 人的行为:吃饭,睡觉,说话,跑,跳等 而我们就是对象(是实实在在存在的个体),具体每个人叫什么名字,年龄多大,身高多高,体重多重等,吃饭怎么吃,睡觉怎么睡,说话怎么说等 描述任意一类事物就是在描述他的属性和行为 分析这句话的属性和行为: 上得了厅堂，下得了厨房，写得了代码，查得出异常，杀得了木马，翻得了围墙（黑客技术），开得起好车，买得起新房，斗得过二奶，打得过流氓。 如何创建对象 (1)类 对现实世界中事物的描述(成员变量和方法)
(2)对象 现实世界中实际存在具体的个体 (3)对象的使用以及内存图 new class Person String name; int age; public void speak() { System.out.println("我的姓名是:" + name + ",我的年龄是:" + age); } } 对象的内存图 看图说话 成员变量和局部变量
(1)作用范围 局部变量：方法内public void method(String name) {} 成员变量：类中，对整个类有效{成员变量分为两种一种静态的,一种非静态的}
(2)存储空间 局部变量：栈内存 成员变量：堆内存{静态的成员变量在方法区,非静态的在对象中在堆内存中}
(3)初始化值 局部变量：在使用前必须手动给值 成员变量：jvm默认初始化值。int 0 byte 0 short 0 long 0 double 0.0 boolean false char '\u0000' class Person { int num = 10; public void method(){ int num = 20 ; System.out.println(num); } }
匿名对象
(1) 当对对象中的功能只执行一次的时候使用。否则，请你使用有名字的对象。
Person p = new Person(); p.show(); p.show(); new Person().show(); new
Person().show(); (2)用于作为实际参数进行传递。 Person p = new Person();
method(p); method(new Person()); public static void method(Person p){} (3)是否可以用匿名对象调用属性,是否有意义?
(2) 封装 (1)封装的好处：便于重复使用，安全性高。 (2)private权限修饰符 class
Demo{ private int age;//把属性私有对外提供公共的访问方法,可控性提高了 public void setAge(int age){ if(age>0 && age<=200){ this.age = age; }else { System.out.println("请回火星"); } } public int getAge(){ return age; } /* 设置是setXxx要传参数 获取是getXxx要返回值类型,返回值类型和属性一致 */ } class DemoTest{ public static void main(String[] args) { Demo d = new Demo(); d.setAge(-
20); System.out.println(d.getAge()); } } this关键字及其使用场景 (1)代表当前对象的引用。使用的时候，谁调用方法，this就代表谁。 (2)什么时候使用this呢？ A：当局部变量和成员变量重名的时候,可以用this进行区分。 B：this调用成员方法 C：构造函数中使用this this() 必须放在第一行。 同下面的道理： Person(String name){ this.name = name; System.out.println("有一个参数的构造函数"); } Person(String name,int age){ this("张三"); this.name = name; this.age = age; System.out.println("有两个参数的构造函数"); } Person p = new Person("lisi",20); Person p2 = new Person("wangwu");
第二篇：JAVA练习题(面向对象)
《JAVA练习题》面向对象
一、 判断正误：
1. Java语言为所有的Java程序自动导入包“java.lang”，因此，Java程序可以直接用
“java.lang”中的类和接口。位于类继承关系层次结构树的根部的类Object就是在包“java.lang”中的一个类。
2. 有时候为了避免引起混淆，构造方法的方法名可以不与所属类名同名。
3. 构造方法一般不允许有任何返回值，因此需要在返回类型处标注为void.
4. 任何类都必须显式地定义该类的构造方法，以便对类的成员进行各种初始化操作。
5. 运行下面程序将在控制台窗口中输出a。
public class A{
public A ( ){
char c=’a’;}
public static void main(String args[ ]) {
System.out.println( c );}
}
6. 如果在定义一个类的时候没有用到关键字extends，则这个类没有直接父类。
7. 在同一个类中，不允许存在具有相同方法名和相同参数类型列表的方法，即使该方法
的返回类型不相同。
8. 抽象方法不能含有方法体，并且必须在抽象类中。
9. 抽象类是不能实例化的，抽象类的实例化，应当通过其不具有抽象属性的子类来创建。
二、 填空：
1. 填空面名对象的计算机语言一般应具有3个基本特征，分别是__________________。
2. 在下面的程序编译之后，按“java A 1 2 3”方式运行的结果是：_______。
public class A {
public static void main(String args[ ]) {
int i;
for(i=0;i<args.length;i++)
{System.out.println(“args[“+i+”]=”+args[i]+”;”);
}
}
}
3. 请按要求完成下面的程序，最终该程序的输出结果是：________。
class A {
public int m;
public A(int d)
{ m=d; }
}
public class B extends A {
public int n;
public B(int ds, int d) {
____________________// 要求将其父类的成员m初始化为ds的值
n=d;
}
public static void main(String args[ ]) {
1
B s=new B(2,3);
System.out.println(s.n+s.m);
} }
4. 下面程序输出的结果是_______。
public class A {
static int m=0;
public int s( ) {
m++;
return m;
}
public static void main(String args[ ]) {
A a=new A( );
A b=new A( );
A c=new A( );
a.s ( );
b.s ( );
c.s ( );
int i=a.s( );
System.out.println(i); }}
三、选择题：
1. 对于下面哪些类定义，可以通过“new A( )”生成类“A”的实例对象？
A.
public class A
{
}
B.
public class A
{ public A(void) { }
}
C.
public class A
{public A(String s) { }
｝
Ｄ.
public class A
{public void A ( ) { }
public A(String s) { }
｝
2. 关于下面程序，哪些结论是正确的？（ ）
public class A {
public A( ) {
System.out.print(“2”);
}
2
public static void main(String args[ ]) {
A s=new A( );
s.A( );
System.out.print(“1”); } }
A. 程序可以通过编译并正常运行，结果输出“21”。
B. 程序可以通过编译并正常运行，结果输出“221”。
C. 程序无法通过编译。
D. 程序可以通过编译，但无法正常运行。
3. 下面程序的输出是什么？
public class A {
int m=2;
String s=null;
A( )
{ m=3;
s=”constructor”; }
public static void main(String args[ ]) {
A app=new A( );
System.out.println(app.m+app.s);
}}
A.3null B.3constructor C.2constructor D.2null
4. 下面程序的输出是什么？
class A {
int m=2;
String s=null;
void A( )
{ m=3;
s=”constructor”; }
public static void main(String args[ ]) {
A app=new A( );
System.out.println(app.m+app.s);
}}
A.3null B.3constructor C.2constructor D.2null
5.己知字母‘a’和‘b’所对应的数值分别是97和98。关于下面程序代码，哪些选项的结论是正确的？
public class A {
static char name;
static int age;
public static void setData(char n) {
name=n;}
public static void setData(int m) {
age=m;}
public static void main(String args[ ]) {
setData((int)’a’);
setData((char)98);
3
System.out.println(“Name:”+name+”; Age:”+age); }}
A.程序可以通过编译并正常运行，结果输出“Name:a; Age:98”
B.程序可以通过编译并正常运行，结果输出“Name:b; Age:97”
C.程序可以通过编译并正常运行，结果输出“Name:b; Age:98”
D.程序可以通过编译并正常运行，结果输出“Name:a; Age:97” E程序无法通过编译
6.关于下面程序，哪些选项的结论是正确的？
class A{
public abstract void m( );
}
class B extends A {
public void m( )
{ System.out.print(“1”);
}
}
class C extends A {
public void m( )
{ System.out.println(“2”);
}
}
public class T{
public static void main(String args[])
{ A d=new B();
d.m( );
d=new B( );
d.m( ); }
}
A.程序可以通过编译并正常运行，结果输出“12”。
B.程序可以通过编译并正常运行，结果输出“11”。
C.程序无法通过编译，因为类型转换不合法。
D.程序无法通过编译，因为类A的定义不对。
7.下面程序的输出是什么？
class A{
static int m=0;
}
class T{
public static void main(String args[ ]) {
A a=new A( );
A b=new A( );
a.m=1;
b.m=2;
System.out.println(a.m);
}
4
}
A.0 B.1 C.2 D.上面的程序含有编译错误
8.设在一个Java包Kit1中含有源程序文件A.java，其内容如下： package kit1;
public class A {
public A( ) {
System.out.print(“1”); }
}
在另一个包中含有源程序文件B.java，其内容如下：
package kit2;
import kit1.A;
public class B extends A {
public B( )
{ System.out.print(“2”);
}
public static void main(String args[ ]) {
B t=new B( );
} }
A.程序可以通过编译并正常运行，结果输出“12”
B.程序可以通过编译并正常运行，结果输出“21”
C.程序可以通过编译并正常运行，结果输出“2”
D.程序无法通过编译
9.设在一个Java包Kit1中含有源程序文件A.java，其内容如下： package kit1;
class A {
public A( ) {
System.out.print(“1”); }
}
在另一个包中含有源程序文件B.java，其内容如下：
package kit2;
import kit1.A;
public class B extends A {
public B( )0
{ System.out.print(“2”);
}
public static void main(String args[ ]) {
B t=new B( );
} }
A.程序可以通过编译并正常运行，结果输出“12”
B.程序可以通过编译并正常运行，结果输出“21”
C.程序可以通过编译并正常运行，结果输出“2”
D.程序无法通过编译
5