Java 面向对象编程思想---类及其方法的调用，分解质因数，界面交互方法 int string 类型转换 陈光剑
面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP 达到了软件工程的三个主要目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息。
1967年挪威计算中心的Kisten Nygaard和Ole Johan Dahl开发了Simula67语言，它提供了比子程序更高一级的抽象和封装，引入了数据抽象和类的概念，它被认为是第一个面向对象语言。20世纪70年代初，Palo Alto研究中心的Alan Kay所在的研究小组开发出Smalltalk语言，之后又开发出Smalltalk-80，Smalltalk-80被认为是最纯正的面向对象语言，它对后来出现的面向对象语言，如Object-C，C++，Self，Eiffl都产生了深远的影响。随着面向对象语言的出现，面向对象程序设计也就应运而生且得到迅速发展。之后，面向对象不断向其他阶段渗透，1980年Grady Booch提出了面向对象设计的概念，之后面向对象分析开始。1985年，第一个商用面向对象数据库问世。1990年以来，面向对象分析、测试、度量和管理等研究都得到长足发展。
面向对象程序设计中的概念主要包括：对象、类、数据抽象、继承、动态绑定、数据封装、多态性、消息传递。通过这些概念面向对象的思想得到了具体的体现。
1）对象（Object) 可以对其做事情的一些东西。一个对象有状态、行为和标识三种属性。
2）类（class) 一个共享相同结构和行为的对象的集合。
3）封装（encapsulation)： 第一层意思：将数据和操作捆绑在一起，创造出一个新的类型的过程。
第二层意思：将接口与实现分离的过程。
4）继承 类之间的关系，在这种关系中，一个类共享了一个或多个其他类定义的结构和行为。继承描述了类之间的“是一种”关系。子类可以对基类的行为进行扩展、覆盖、重定义。
5）组合 即使类之间的关系也是对象之间的关系。在这种关系中一个对象或者类包含了其他的对象和类。
组合描述了“有”关系。
6）多态 类型理论中的一个概念，一个名称可以表示很多不同类的对象，这些类和一个共同超累有关。因此，这个名称表示的任何对象可以以不同的方式响应一些共同的操作集合。
7）动态绑定 也称动态类型，指的是一个对象或者表达式的类型直到运行时才确定。通常由编译器插入特殊代码来实现。与之对立的是静态类型。
8）静态绑定 也称静态类型，指的是一个对象或者表达式的类型在编译时确定。
9）消息传递 指的是一个对象调用了另一个对象的方法（或者称为成员函数）。
10）方法 也称为成员函数，是指对象上的操作，作为类声明的一部分来定义。方法定义了可以对一个对象执行那些操作。
此外，Simula 67的思想亦被应用在许多不同的语言，如Lisp、Pascal。
面向对象程序设计在80年代成为了一种主导思想，这主要应归功于C++——C语言的扩充版。在图形用户界面（GUI）日渐崛起的情况下，面向对象程序设计很好地适应了潮流。GUI和面向对象程序设计的紧密关联在Mac OS X中可见一斑。Mac OS X是由Objective-C语言写成的，这一语言是一个仿Smalltalk的C语言扩充版。面向对象程序设计的思想也使事件处理式的程序设计更加广泛被应用（虽然这一概念并非仅存在于面向对象程序设计）。一种说法是，GUI的引入极大地推动了面向对象程序设计的发展。
在过去的几年中，Java语言成为了广为应用的语言，除了它与C和C++语法上的近似性。Java的可移植性是它的成功中不可磨灭的一步，因为这一特性，已吸引了庞大的程序员群的投入。
近日，一些既支持面向对象程序设计，又支持面向过程程序设计的语言悄然浮出水面。它们中的佼佼者有Python、Ruby等等.
正如面向过程程序设计使得结构化程序设计的技术得以提升，现代的面向对象程序设计方法使得对设计模式的用途、契约式设计和建模语言（如UML）技术也得到了一定提升。
题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。
程序算法分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
(2)如果n <> k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数你n,重复执行第一步。
(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。
/**
*
*/
package iSword;
/**
* @author chenguangjian/iSword 2013-3-30
*
*/
import iSword.data_basics;
public class factor_number
{
/**
* @param args
*/
static data_basics b=new data_basics();
public static void main(String[] args)
{
// TODO Auto-generated method stub
factor_number f=new factor_number();
int N=b.input();
f.factor_number(N);
}
public void factor_number(int n){
b.print(n+"=");
int k=2;
while(k<=n){
if(k==n){
b.print(String.valueOf(n));// integer type ---> String type
break;
}
else if(n%k==0){
b.print(k+"*");
n=n/k;
}
else k++;
}
}
}
/**
*
*/
package iSword;
import java.util.Scanner;
//*****************************主类************************************************//
public class data_basics {
/**
* @author chenguangjian/iSword 2013-3-30
*
*/
/*
* 输入一个整数
*/
public int input(){
int a;
Scanner s=new Scanner(System.in);
System.out.print("Please input an integer: ");
a=s.nextInt();
return a;
}
/*
* 自定义系统输出函数print(String str)
*/
public void print(String str){
System.out.print(str);
}
public void find_prime_numbers(int N){
print("2,3,");
int count=0;
for(int i=2;i<N;i++){
boolean b=false;
for(int j=2;j<=Math.sqrt(i);j++)
{
if(i % j==0) { // 逐个相除,一直到sqrt(i)不能整除的就是质数
b=false;
break;
}
else {
b=true;
}
}
if (b==true){
count++;
print(i+",");
}
}
print("The 1-N has"+count+" prime numbers. " );
}
public void find_full_number(int N) {
for(int i=1;i<N;i++){
//计算因子之和 t
int t=0;
for (int j=1;j<=i/2;j++){
if(i%j==0){
t=t+j;
}
}
if(t==i) {
print(i+" = ");
for (int k=1;k<=i/2;k++){
if(i%k==0 ) {
print(k+" + ");
}
}
print(" \n\n");
}
}
}
/**
* main()主函数：程序执行入口
* @param args
*
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
data_basics dtb=new data_basics();
System.out.println("begin 求最大公约数和最小公倍数---------" );
//begin 求最大公约数和最小公倍数---------------------------------
int a,b,m;
Scanner s=new Scanner(System.in);
dtb.print("Please input a: ");
a=s.nextInt();
dtb.print("Please input b: ");
b=s.nextInt();
//调用主实现类 greatestCommonDivisor
greatest_common_divisor g=new greatest_common_divisor();
//调用主实现类 greatestCommonDivisor里面的主方法
m=g.get_greatest_commonDivisor(a, b);
int n=a*b/m;
System.out.println("最大公约数: " + m);
System.out.println("最小公倍数: " + n);
//end求最大公约数和最小公倍数---------------------------------
System.out.println("end 求最大公约数和最小公倍数---------" );
System.out.println("begin 求1-N质数-------------------------" );
//begin 求1-N质数 --------------------------------------------------
dtb.find_prime_numbers(100); //N=100
//end 求1-N质数--------------------------------------------------
System.out.println("end 求1-N质数-------------------------" );
System.out.println("begin 求1-1000内的完全数-------------------------" );
dtb.find_full_number(1000);//求1-1000内的完全数
System.out.println("end 求1-1000内的完全数-------------------------" );
}
}
//******************************************************************************//
//最大公约数：主实现类
class greatest_common_divisor{
// 主方法
public int get_greatest_commonDivisor(int x, int y){
int t;
if (x<y){
t=x;
x=y;
y=t;
}
while(y!=0){
if (x==y) return x;
else{
int k=x%y;
x=y;
y=k;
}
}
return x;
}
}
//******************************************************************************//
Please input an integer: 1000
1000=2*2*2*5*5*5
java.lang
类 String
java.lang.Object
String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。例如：
String str = "abc";
等效于：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
| 方法摘要 | |
|---|---|
char |
charAt(int index) 返回指定索引处的 char 值。 |
int |
codePointAt(int index) 返回指定索引处的字符（Unicode 代码点）。 |
int |
codePointBefore(int index) 返回指定索引之前的字符（Unicode 代码点）。 |
int |
codePointCount(int beginIndex, int endIndex)返回此 String 的指定文本范围中的 Unicode 代码点数。 |
int |
compareTo(String anotherString)按字典顺序比较两个字符串。 |
int |
compareToIgnoreCase(String str)按字典顺序比较两个字符串，不考虑大小写。 |
String |
concat(String str)将指定字符串连接到此字符串的结尾。 |
boolean |
contains(CharSequence s)当且仅当此字符串包含指定的 char 值序列时，返回 true。 |
boolean |
contentEquals(CharSequence cs)将此字符串与指定的 CharSequence 比较。 |
boolean |
contentEquals(StringBuffer sb)将此字符串与指定的 StringBuffer 比较。 |
static String |
copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String。 |
static String |
copyValueOf(char[] data, int offset, int count)返回指定数组中表示该字符序列的 String。 |
boolean |
endsWith(String suffix)测试此字符串是否以指定的后缀结束。 |
boolean |
equals(Object anObject)将此字符串与指定的对象比较。 |
boolean |
equalsIgnoreCase(String anotherString)将此 String 与另一个 String 比较，不考虑大小写。 |
static String |
format(Locale l,String format, Object... args) 使用指定的语言环境、格式字符串和参数返回一个格式化字符串。 |
static String |
format(String format,Object... args) 使用指定的格式字符串和参数返回一个格式化字符串。 |
byte[] |
getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 |
byte[] |
getBytes(Charset charset)使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。 |
void |
getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin)已过时。 该方法无法将字符正确转换为字节。从 JDK 1.1 起，完成该转换的首选方法是通过 getBytes() 方法，该方法使用平台的默认字符集。 |
byte[] |
getBytes(String charsetName)使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 |
void |
getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)将字符从此字符串复制到目标字符数组。 |
int |
hashCode() 返回此字符串的哈希码。 |
int |
indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 |
int |
indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 |
int |
indexOf(String str)返回指定子字符串在此字符串中第一次出现处的索引。 |
int |
indexOf(String str, int fromIndex)返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。 |
String |
intern() 返回字符串对象的规范化表示形式。 |
boolean |
isEmpty() 当且仅当 length() 为 0 时返回 true。 |
int |
lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 |
int |
lastIndexOf(int ch, int fromIndex)返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。 |
int |
lastIndexOf(String str)返回指定子字符串在此字符串中最右边出现处的索引。 |
int |
lastIndexOf(String str, int fromIndex)返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。 |
int |
length() 返回此字符串的长度。 |
boolean |
matches(String regex)告知此字符串是否匹配给定的正则表达式。 |
int |
offsetByCodePoints(int index, int codePointOffset)返回此 String 中从给定的 index 处偏移 codePointOffset 个代码点的索引。 |
boolean |
regionMatches(boolean ignoreCase, int toffset,String other, int ooffset, int len) 测试两个字符串区域是否相等。 |
boolean |
regionMatches(int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。 |
String |
replace(char oldChar, char newChar)返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 |
String |
replace(CharSequence target,CharSequence replacement) 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。 |
String |
replaceAll(String regex,String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 |
String |
replaceFirst(String regex,String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。 |
String[] |
split(String regex)根据给定正则表达式的匹配拆分此字符串。 |
String[] |
split(String regex, int limit)根据匹配给定的正则表达式来拆分此字符串。 |
boolean |
startsWith(String prefix)测试此字符串是否以指定的前缀开始。 |
boolean |
startsWith(String prefix, int toffset)测试此字符串从指定索引开始的子字符串是否以指定前缀开始。 |
CharSequence |
subSequence(int beginIndex, int endIndex)返回一个新的字符序列，它是此序列的一个子序列。 |
String |
substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。 |
String |
substring(int beginIndex, int endIndex)返回一个新字符串，它是此字符串的一个子字符串。 |
char[] |
toCharArray() 将此字符串转换为一个新的字符数组。 |
String |
toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。 |
String |
toLowerCase(Locale locale)使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。 |
String |
toString() 返回此对象本身（它已经是一个字符串！）。 |
String |
toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。 |
String |
toUpperCase(Locale locale)使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。 |
String |
trim() 返回字符串的副本，忽略前导空白和尾部空白。 |
static String |
valueOf(boolean b) 返回 boolean 参数的字符串表示形式。 |
static String |
valueOf(char c) 返回 char 参数的字符串表示形式。 |
static String |
valueOf(char[] data) 返回 char 数组参数的字符串表示形式。 |
static String |
valueOf(char[] data, int offset, int count)返回 char 数组参数的特定子数组的字符串表示形式。 |
static String |
valueOf(double d) 返回 double 参数的字符串表示形式。 |
static String |
valueOf(float f) 返回 float 参数的字符串表示形式。 |
static String |
valueOf(int i) 返回 int 参数的字符串表示形式。 |
static String |
valueOf(long l) 返回 long 参数的字符串表示形式。 |
static String |
valueOf(Object obj)返回 Object 参数的字符串表示形式。 |
Returns the string representation of the int argument.
The representation is exactly the one returned by the Integer.toString method of one argument.
- Parameters:
-
i an
int. - Returns:
-
a string representation of the
intargument. - See Also:
- java.lang.Integer.toString(int, int)
Returns a string representation of the first argument in the radix specified by the second argument.
If the radix is smaller than Character.MIN_RADIX or larger than Character.MAX_RADIX, then the radix 10 is used instead.
If the first argument is negative, the first element of the result is the ASCII minus character'-' ('\u002D'). If the first argument is not negative, no sign character appears in the result.
The remaining characters of the result represent the magnitude of the first argument. If the magnitude is zero, it is represented by a single zero character'0' ('\u0030'); otherwise, the first character of the representation of the magnitude will not be the zero character. The following ASCII characters are used as digits:
These are0123456789abcdefghijklmnopqrstuvwxyz
'\u0030' through
'\u0039' and
'\u0061' through
'\u007A'. If
radix is
N, then the first
N of these characters are used as radix-
N digits in the order shown. Thus, the digits for hexadecimal (radix 16) are
0123456789abcdef. If uppercase letters are desired, the
java.lang.String.toUpperCase() method may be called on the result:
Integer.toString(n, 16).toUpperCase()
- Parameters:
- i an integer to be converted to a string.
- radix the radix to use in the string representation.
- Returns:
- a string representation of the argument in the specified radix.
- See Also:
- java.lang.Character.MAX_RADIX
- java.lang.Character.MIN_RADIX
在多函数程序中，许多重要的数据被放置在全局数据区，这样它们可以被所有的函数访问。每个函数都可以具有它们自己的局部数据。
这种结构很容易造成全局数据在无意中被其他函数改动，因而程序的正确性不易保证。面向对象程序设计的出发点之一就是弥补面向过程程序设计中的一些缺点：对象是程序的基本元素，它将数据和操作紧密地连结在一起，并保护数据不会被外界的函数意外地改变。
比较面向对象程序设计和面向过程程序设计，还可以得到面向对象程序设计的其他优点：
1）数据抽象的概念可以在保持外部接口不变的情况下改变内部实现，从而减少甚至避免对外界的干扰；
2）通过继承大幅减少冗余的代码，并可以方便地扩展现有代码，提高编码效率，也减低了出错概率，降低软件维护的难度；
3）结合面向对象分析、面向对象设计，允许将问题域中的对象直接映射到程序中，减少软件开发过程中中间环节的转换过程；
4）通过对对象的辨别、划分可以将软件系统分割为若干相对为独立的部分，在一定程度上更便于控制软件复杂度；
5）以对象为中心的设计可以帮助开发人员从静态（属性）和动态（方法）两个方面把握问题，从而更好地实现系统；
6）通过对象的聚合、联合可以在保证封装与抽象的原则下实现对象在内在结构以及外在功能上的扩充，从而实现对象由低到高的升级。