Java面向对象编程（二）

//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}

重载练习

编写程序，定义三个重载方法并调用。方法名为mOL。

三个方法分别接收一个int参数、两个int参数、一个字符串参数。分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。

在主类的main ()方法中分别用参数区别调用三个方法。

public class OOPTest005 {
	public static void main(String[] args) {
		OOPTest5 pri=new OOPTest5();
		pri.mOL(2);
		pri.mOL("light");
		pri.mOL(2, 3);
	}
	
}
class OOPTest5{
	public void mOL(int x,int y) {
		System.out.println(x*y);
		
	}
	public void mOL(int x) {
		System.out.println(x*x);
		
	}
	public void mOL(String x) {
		System.out.println(x);
		
	}
}

运行结果为：

可变个数的形参

JavaSE 5.0中提供了Varargs(Variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

说明：

1、声明格式：方法名（参数的类型名...参数名）

2、可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个

3、可变个数形参的方法名与同名的方法名之间，彼此构成重载

4、可变参数方法的使用与方法参数部分使用数组是一致的

5、方法的参数部分有可变形参，需要放在形参声明的最后

6、在一个方法的形参位置，最多只能声明一个可变个数形参

可变个数形参示例

public void test(String[] msg){
    System.out.println(“含字符串数组参数的test方法 ");
}
public void test1(String book){
    System.out.println(“****与可变形参方法构成重载的test1方法****");
}
public void test1(String ... books){
    System.out.println("****形参长度可变的test1方法****");
}
public static void main(String[] args){
    TestOverload to = new TestOverload();
    //下面两次调用将执行第二个test方法
    to.test1();
    to.test1("aa" , "bb");
    //下面将执行第一个test方法
    to.test(new String[]{"aa"});
}

方法参数的值传递机制

方法，必须由其所在的类或对象调用才有意义。若方法含有参数：

形参：方法声明时用的参数（方法定义时，生命的小括号内的参数）

实参：方法调用时用实际传递给形参的参数值

java的实参值如何传入方法呢？

java方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

如果参数是基本数据类型，则参数传递给形参的是实参真是存储的值

如果参数时引用数据类型，则参数传递给形参的是实参存储数据的地址值

关于变量的赋值

如果变量是基本数据类型，此时赋值的是变量中所保存的数据值

如果变量是引用数据类型，此时赋值的是变量所保存的地址值

练习：将对象作为参数传递给方法

（1）定义一个Circle1类，包含一个double型的radius属性代表圆的半径，一个 findArea()方法返回圆的面积。

（2）定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：public void printAreas(Circle c, int time) 在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。例如，times为5，则输出半径1，2，3，4，5，以及对应的圆面积。

（3）在main方法中调用printAreas()方法，调用完毕后输出当前半径值。程序运行结果如图所示。

代码：

public class OOPTest006 {
	public static void main(String[] args) {
		int time=5;
		Circle1 c=new Circle1();
		PassObject pass=new PassObject();
		pass.printArea(c, time);
		System.out.println("now the radius is "+(c.radius+1));
	}
}


class Circle1{
	double radius;
	public double findArea() {
		return radius*Math.PI*radius;
	}
}

class PassObject {
	public void printArea(Circle1 c,int time) {
		System.out.println("radius\t\tArea");
		for(int i=1;i<=time;i++) {
			c.radius=i;
			System.out.println(c.radius+"\t\t"+c.findArea());
		}
		
	}
	
}

运行结果如图所示：

递归方法

递归方法：一个方法体内调用它自身

方法递归包含了一种隐式的循环，他会重复执行某段代码，但这种重复执行无需循环控制

递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

方法递归必须有递归出口

递归实例

//计算1-100之间所有自然数的和
public int sum(int num){
    if(num == 1){
        return 1;
    }else{
        return num + sum(num - 1);
    }
}

面向对象特征之一：封装与隐藏

在程序设计中往往追求“高内聚、低耦合”

高内聚：类的内部数据操作细节自己完成，不允许外部干涉

低耦合：仅对外暴露少量方法

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。

信息的封装和隐藏

java中通过将数据声明为私有的（private），在提供公共的（public）方法：getXxx()和SetXxx()实现对该属性的操作，以实现以下目的：

1、隐藏一个类中不需要对外提供的实现细节；

2、使用者只能通过事先定制好的方法来访问数据，可以方便的加入控制逻辑，限制对属性的不合理操作

3、便于修改，增强代码的可维护性

封装性的体现

1、将属性的私有，同时提供公共的方法来实现对该属性的操作

2、不对外暴露私有的方法

...

实例

class Animal {
    private int legs;// 将属性legs定义为private，只能被Animal类内部访问
    public void setLegs(int i) { // 在这里定义方法 eat() 和 move()
    if (i != 0 && i != 2 && i != 4) {
        System.out.println("Wrong number of legs!");
            return;
    }
        legs = i;
}
    public int getLegs() {
        return legs;
    }
}
public class Zoo {
    public static void main(String args[]) {
        Animal xb = new Animal();
        xb.setLegs(4); // xb.setLegs(-1000);
        //xb.legs = -1000; // 非法
        System.out.println(xb.getLegs());
    }
}

四种访问权限修饰符

java权限修饰符public、protected、（缺省）、private置于类的成员定义之前，用来限定对象对该类成员的访问权限。

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	yes	no	no	no
缺省	yes	yes	no	no
procted	yes	yes	yes	no
public	yes	yes	yes	yes

对于class的权限修饰只可以用public和default（缺省）

public类可以在任意地方被访问

default类只可以被同一个包内部的类访问

练习

创建程序,在其中定义两个类：Person和PersonTest类。定义如下：用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。在 PersonTest 类中实例化 Person 类的对象 b ，调用 setAge() 和 getAge()方法，体会Java的封装性。

代码：

//封装与隐藏
public class PersonTest {
	public static void main(String[] args) {
		Person b=new Person();
		b.setAge(20);
		System.out.println(b.getAge());/*输出为20*/
	}
}
  

class Person{
	private int age;
	
	public void setAge(int a) {
		if(a>0&&a<130) {
			age=a;
		}else {
			System.out.println("年龄不在范围内");
		}
	}
	
	public int getAge() {
		return age;
	}
	
}

类的成员之三：构造器（或构造方法）

构造器的特征

1、它具有与类相同的名称

2、他不声明返回值类型（与声明void不同）

3、不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

构造器的作用

1、创建对象

2、给对象进行初始化

语法格式

修饰符类名（参数列表）{

初始化语句；

}

实例

/*
*创建Animal类的实例：Animal a = new Animal();
*调用构造器，将legs初始化为4。
*/


public class Animal {
    private int legs;
    // 构造器
    public Animal() {
        legs = 4;
    } 
    public void setLegs(int i) {
        legs = i;
    }
    public int getLegs() {
        return legs;
    }
}

注意：

1、根据参数不同，构造器可以分为以下两种：

隐式无参构造器（系统默认提供）

显示定义一个或多个构造器（无参、有参）

说明：默认提供的构造器的权限修饰符与该类的权限修饰符相同

2、java语言中，每个类都至少有一个构造器

3、一旦显式的定义了构造器，则系统不再提供默认构造器

4、一个类可以创建多个重载的构造器

5、父类的构造器不可以被子类继承

练习

编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，同时声明公共方法访问私有变量。此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。

代码：

//构造器
public class TriAngleTest {
	public static void main(String[] args) {
		TriAngle tri=new TriAngle();
		
		tri.setBase(5);
		tri.setHeight(5);
		System.out.println(tri.getHeight()*tri.getBase()/2);
	}
}


class TriAngle{
	private int base;
	private int height;
	
	public TriAngle() {
		
	}
	
	public void setBase(int b) {
		base=b;
	}
	
	public int getBase() {
		return base;
	}
	
	public void setHeight(int h) {
		height=h;
	}
	public int getHeight() {
		return height;
	}
}

运行结果如下：

构造器重载

构造器一般用来创建对象的同时初始化对象

构造器重载使得对象的创建更加灵活，方便创建不同的对象

构造器重载，列表参数必须不同

属性赋值的过程

赋值的位置

1、默认初始化

2、显示初始化

3、构造器中初始化

4、通过“对象.属性”或“对象.方法”的方式赋值

赋值的先后顺序

1-2-3-4

JavaBean

JavaBean是一种Java语言写成的可重用组件。

所谓javaBean，是指符合如下标准的Java类：

1、类是公共的

2、有一个无参的公共的构造器

3、有属性，且有对应的get、set方法

用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP 页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

UML类图

1、 + 表示 public 类型， - 表示 private 类型，#表示protected类型

2、方法的写法: 方法的类型(+、-) 方法名(参数名：参数类型)：返回值类型

关键字：this的使用

this是什么？

在Java中，this关键字比较难理解，它的作用和其词义很接近。

它在方法内部使用，即这个方法所属对象的引用；

它在构造器内部使用，表示该构造器正在初始化的对象。

this可以调用类的属性、类的方法和构造器

当在方法内需要用到该方法的对象时，就用this。eg：this.name = name;

使用this调用属性、方法

1、在任一方法或构造器内，如果使用当前类的成员变量或成员方法，可以在前面添加this，增强程序的阅读性。一般来说，this可以省略。

2、形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表名该变量是类的成员变量。此时，this不可省略。

3、使用this访问属性和方法时，如果在本类中未找到，或从父类中查找

使用this调用构造器

this可以作为一个类中构造器相互调用的特殊格式

注意：

1、可以在类的构造器中使用“this(形参列表)”的方式，调用在本类中重载的其它构造器

2、构造器中不能通过“this(形参列表)”的方式调用自身构造器

3、如果一个类中声明了n个构造器，则最最多有n-1个构造器使用了“this(形参列表)”

4、“this(形参列表)”必须声明在类的构造器的首行

5、在类的一个构造器中，做多只能声明一个“this(形参列表)”

练习

代码：

public class ThisTest {
	public static void main(String[] args) {
		Boy b=new Boy();
		Girl g=new Girl();
		b.setAge(18);
		b.setName("jack");
		g.setName("rose");
//		b.marry(g);
		g.marry(b);
	}
}


class Boy{
	private String name;
	private int age;
	
	public Boy() {
		
	}
	public void setName(String name) {
		this.name=name;
	}
	public String getName() {
		return this.name;
	}
	public void setAge(int age) {
		this.age=age;
	}
	public int getAge() {
		return this.age;
	}
	
	public void marry(Girl girl) {
		System.out.println(girl.getName()+" marry me!");
	}
	
	public void shout() {
		System.out.println("marry me!");
	}
}


class Girl{
	private String name;
	private int age;
	public Girl() {
		
	}
	public void setName(String name) {
		this.name=name;
	}
	public String getName() {
		return this.name;
	}
	public void marry(Boy boy) {
		System.out.println(boy.getName()+" i will  marry you!");
		boy.marry(this);
	}
	
	
	/**
	 * @Description   比较两个对象的大小
	 * @param girl
	 * @return 正数：当前对象大；复数：当前对象小；0：当前对象与形参对象相等
	 */
	
	public int compare(Girl girl) {
		if(this.age>girl.age) {
			return 1;
		}else if(this.age<girl.age) {
			return -1;
		}
		else {
			return 0;
		}
	}
}

运行结果如下：

关键字：package、import的使用

关键字——package

package语句作为java源文件的第一条语句，指明文件中定义的类所在的包（若缺省该语句，则指定为无包名）

格式

package 顶层包名.子报名；

包对应与文件系统的目录，package语句中，用“.”来指明包（目录）的层次；

包通常用小写单词表示。通常使用所在公司域名的倒置

源文件布局

包的作用

1、包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式

2、包可以包含类和子包，划分项目层次，便于管理

3、解决类命名冲突的问题

4、控制访问权限

MVC设计模式

MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，与数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。

模型层 model 主要处理数据

>数据对象封装 model.bean/domain

>数据库操作类 model.dao

>数据库 model.db

控制层 controller 处理业务逻辑

>应用界面相关 controller.activity

>存放fragment controller.fragment

>显示列表的适配器 controller.adapter

>服务相关的 controller.service

>抽取的基类 controller.bas

视图层 view 显示数据

>相关工具类 view.utils

>自定义view view.ui

JDK中主要的包介绍

1、 java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和 Thread，提供常用功能

2、 java.net----包含执行与网络相关的操作的类和接口。

3、java.io ----包含能提供多种输入/输出功能的类。

4、java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。

5、java.text----包含了一些java格式化相关的类

6、java.sql----包含了java进行JDBC数据库编程的相关类/接口

7、java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S

关键字——import

为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类。

语法格式

import 包名. 类名;

注意

1、在源文件中使用import显式的导入指定包下的类或接口

2、声明在包的声明和类的声明之间。

3、如果需要导入多个类或接口，那么就并列显式多个import语句即可

4、如果使用的方式是“import.xxx.*”,则表明可以使用xxx包下的所有结构，但如果是使用xxx子包下的结构，则仍需显式导入

5、如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。

6、如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。

7、import static组合的使用：调用指定类或接口下的静态的属性或方法

要向着光

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象编程（二）

1、 java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和 Thread，提供常用功能2、 java.net----包含执行与网络相关的操作的类和接口。3、java.io ----包含能提供多种输入/输出功能的类。4、java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。5、java.text----包含了一些java格式化相关的类。
复制链接

扫一扫