本文详细介绍了Java编程的基础知识，包括主类的概念、数组的定义及使用、多维数组的声明、二分查找算法的实现、String类与StringBuffer类的区别及应用、类与对象的基本概念、静态成员变量和静态成员函数的定义、this与super关键字的使用、抽象类与接口的特性及其区别。
一个程序有多个类，但是只有一个类前面允许加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修饰的类被称为抽象类。抽象类是一种没有具体实例的类，它的主要用途是用来描述概念性的内容，这样可以提高开发效率，更好的统一接口。用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();
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
