C/C++程序员眼中的Java

JAVA:
一个程序有多个类，但是只有一个类前面允许加public，这个类称为主类，且java源程序的名字必须与主类的名字完全一致，扩展名必须为java，主类中含有main方法，是整个程序的入口。一个java文件中可以有多个类，但是只有一个主类。


数组的定义：
int [] a1 = new int[10];
int a2[] = new int[10];
a.length;
多维数组：
int a[][] = int[2][];//一维的长度可以不指定，但是必须声明二维的长度。
a[0] = new int[2];
a[1] = new int[4];
a[0].length == 2 true;
a[1].length == 4 true;

代码示例（输入输出，类的调用）：

import java.io.*; class findsearch { int binarySearch( int arr[], int key) { int low = 0; int high = arr.length -1; int mid = ( low + high ) / 2; while( low <= high && arr[mid] != key) { if( arr[mid] < key ) low = mid + 1; else high = mid - 1; mid = ( low + high ) / 2; } if( low > high ) mid = -1; return mid; } } public class find { public static void main( String[] args) throws IOException { BufferedReader keyin = new BufferedReader( new InputStreamReader( System.in)); int i, k, key, mid; String c1; int arr[] = {2, 4, 7, 9, 18, 25, 34, 56, 68, 89}; System.out.println("原始数据为："); for( i = 0; i < arr.length; i++) System.out.print(" " + arr[i] ); System.out.println("\n"); System.out.println("输入要查找数："); c1=keyin.readLine(); key = Integer.parseInt( c1 ); findsearch p1 = new findsearch(); mid = p1.binarySearch( arr, key); if( mid == -1 ) System.out.println("对不起，未找到"); else System.out.println("所查找的数在数组中的位置下标是：" + mid); } }

String类和StringBuffer类：
String类的对象是一经创建便不能变动内容的字符串变量，对String类的对象只能进行查找和比较等操作。用StirngBuffered类创建的对象在操作中可以更改字符串的内容，因此也被称为字符串变量。对于StringBuffered类的对象可以做添加、插入、删除等操作。至于这两个类的常用方法，最好的方法就是查看帮助文档。

代码示例(String的用法):

public class Stringfunction { public static void main( String[] args) { String s1 = "THIS IS A TEST STRING!"; String t = s1.concat(" CONCAT"); boolean result1 = s1.equals( "this is a test string!"); boolean result2 = s1.equalsIgnoreCase( "this is a test string!"); String s2 = "THIS IS A TEST STRING!"; String s3 = new String( s1); boolean result3 = s1 == s2; boolean result4 = s1 == s3; System.out.println("s1 = " + s1 ); System.out.println("t = " + t ); System.out.println("result1 = " + result1); System.out.println("result2 = " + result2); System.out.println("result3 = " + result3); System.out.println("result4 = " + result4); } }

对象和类：
定义类时，需要指出三方面：类的标识，属性，方法。
若没有设置访问控制符，则说明该类，属性，或方法具有默认的访问控制权限，这样的类属性和方法只能被同一个包中的类访问和引用。
final可以用来修饰类、属性和方法。分别表示类不能被继承，属性不能被赋值或隐藏，方法不能被重载和覆盖。
静态属性是一个公共的存储单元，不属于任何一个对象，任何一个类的对象都可以访问它，因此，既可以用"类名.静态属性"，也可以用"对象名.静态属性"的形式访问。
静态方法属于整个类，只能处理静态属性，调用方式与静态属性类似。

代码示例（定义类，创建对象，定义静态成员变量和静态成员函数）：

public class Student { private String no; private int innerNo; private String name; private char sex; static double pay; static int nextInnerNo; public Student( String n, String str, char ch)//构造函数 { no = n; innerNo = nextInnerNo; nextInnerNo++; name = str; sex = ch; } static//静态初始化器 { pay = 300; nextInnerNo = 1; } public void printStudent() { System.out.println("Student NO:" + no + " innerNo : " + innerNo + " name :" + name + " sex:" + sex + " 助学补助：" + pay); } public static void main( String args[]) { Student s1 = new Student("2011010101", "周涛", '男'); Student s2 = new Student( "2011010103", "小丽", '女'); s1.printStudent(); s2.printStudent(); } }

this and super ，重载：

代码示例（函数的重载，this和super的使用）：

class Person { protected String name; protected char sex; } class Student extends Person { String speciality; double score; Student( String name, char sex, String speciality, double score) { //this.name = name; super.name = name; super.sex = sex; this.speciality = speciality; this.score = score; } Student() { this( "anonymout", '男', "unknow", 0.0); } void printStudent() { System.out.println("name: " + name + " sex:" + sex + " major: " + speciality + " grade:" + score ); } } public class ThisSuper { public static void main( String[] args) { Student s1 = new Student( "laimingxing", '男', "Computer", 100.0); Student s2 = new Student( "wangkai", '男', "Computer", 99.0); Student s3 = new Student(); s1.printStudent(); s2.printStudent(); s3.printStudent(); } }

abstract and interface:
用abstract修饰的类被称为抽象类。抽象类是一种没有具体实例的类，它的主要用途是用来描述概念性的内容，这样可以提高开发效率，更好的统一接口。用abstract修饰的方法成为抽象方法，抽象方法没有方法体，抽象方法必须存在有抽象类之中,当然抽象类中可以含有非抽象方法。在抽象类的子类中必须实现抽象类中定义的所有抽象方法。由于抽象类主要是用来派生子类，因此抽象类不能用final修饰，抽象类也不呢更有private的属性和方法。
Java不支持多重继承，即一个类只能有一个直接父类。这使得java程序比较简单，便于操作。但是有时候我们还是希望使用多重继承，则可以通过一个类实现多个接口的方法。接口的修饰符与类的修饰符相同，接口之间可以通过extends实现继承关系，而且可以是多重继承，即一个接口可以继承多个接口。由于接口中定义的方法都是公共的，抽象的，成员都是静态的，公共的常量，所有修饰符可以省略。

接口的实现：

interface A { int a = 100; void showA(); } interface B { int b = 200; void showB(); } interface C extends A, B { int c = 300; void showC(); } public class TestInterface implements C { public void showA() { System.out.println(" a = " + a ); } public void showB() { System.out.println(" b = " + b ); } public void showC() { System.out.println(" c = " + c ); } public static void main( String args[]) { TestInterface d = new TestInterface(); d.showA(); d.showB(); d.showC(); } }