2023年Java面向对象程序设计基础.docx

Java面向对象程序设计基础

1 类的结构

1.1 类声明
类的定义：
class A{
成员变量与成员方法的定义
}

1.2 创建对象
对象的创建：
A a; //对象的声明，即定义A类的一个对象，名为a
a=new A(); //对象的创建，即为a对象开辟一个内存区，
//并调用构造方法A()对对象进行初始化

上面两步也可以合并为一步：
A a=new A();

a
●
对象
变量
方法

/*Class1.java*/
class Man{
int height;
int age;
}
public class Class1{
public static void main(String[] args){
Man man1;
man1=new Man();
man1.height=180;
man1.age=20;
System.out.println(man1.height);
System.out.println(man1.age);
}
}

1.3 构造方法
构造方法是在创建对象时调用执行的特殊函数，用于对对象进行初始化。假如编程者没有编写构造方法，编译器会自动提供一个缺省的无参的空构造方法。但假如编程者编写了构造方法，编译器将不再提供缺省的无参的空构造方法。
造方法的名字必须与类名相同，且没有任何返回值，也不可使用void关键字。
可以在构造方法中使用this()来调用其他被重载的构造方法。

/*Class17.java*/
public class Class17{
int a;
public Class17(){ //构造方法
a=10;
}
public static void main(String[] args){
Class17 ob=new Class17();
System.out.println(ob.a);
}
}

/*Class18.java*/
public class Class18{
int a;
public Class18(){
a=10;
}
public Class18(int a){
this.a=a;
}
public static void main(String[] args){
Class18 ob1=new Class18();
Class18 ob2=new Class18(20);
Class18 ob3=new Class18(30);
System.out.println(ob1.a);
System.out.println(ob2.a);
System.out.println(ob3.a);
}
}

/*Class19.java*/
public class Class19{
int a;
public void Class19(){ //这里Class28()不是构造函数
a=10;
}
public static void main(String[] args){
Class19 ob=new Class19();
System.out.println(ob.a);
}
}

2 类的成员

2.1 成员变量和局部变量
类体中定义的变量称为成员变量，而类的成员方法中定义的变量以及方法中的形式参数则称为局部变量。
成员变量在整个类体中有效，而局部变量只在定义它的方法中有效。
使用局部变量之前必须对其进行初始化，否则编译时会犯错。

2.2 关键字this
this代表本类的对象；通过它可以引用本类的成员。
只能在实例方法中使用this关键字。
this()可用于调用本类的构造方法。

/*ThisDemo.java*/
class ThisDemo1{
int a1=1,a2=2;
void ss(){
int a1=10, a2=20;
a1=this.a1;
System.out.println(a1);
System.out.println(a2);
}
}
public class ThisDemo{
public static void main(String args[]){
ThisDemo1 aa=new ThisDemo1();
aa.ss();
System.out.println(aa.a1);
}
}

2.3 类方法和实例方法
有关键字static修饰的称为类方法（又称静态方法）和类变量（又称静态变量），而没有static修饰的称为实例方法和实例变量。
实例方法和实例变量只能通过对象名引用，而类方法和类变量既能通过对象名引用，也能通过类名引用。
类方法只能直接访问本类中的类成员。

/*ConstructorDemo.java*/
class ConstructorDemo1{
int a1,a2;
ConstructorDemo1(){ //构造方法
a1=1; a2=2;
}
static void pntout(String s){ //类方法
System.out.println(s);
}
}
public class ConstructorDemo{
public static void main(String args[]){
ConstructorDemo1 abc=new ConstructorDemo1();
System.out.print("1+2=");
System.out.println(abc.a2 + abc.a1);
ConstructorDemo1.pntout("你们好，朋友们！");
}
}

/*Class3.java*/
public class Class3{
int a;
static void setA(int b){ //静态方法
a=b; //错，静态方法中不能直接访问非静态的成员变量a
}
public static void main(String[] args){
Class3.setA(10);
}
}

/*Class4.java*/
public class Class4{
static int a; //静态变量
static void hello(){ //静态方法
System.out.println("你好~~");
}
static void setA(int b){ //静态方法
a=b;
hello();
}
void printA(){
System.out.println(a); //非静态方法可以访问静态变量a
hello(); //非静态方法也可以访问静态方法hello()
}
public static void main(String[] args){
Class4.setA(100);
Class4 ob=new Class15();
ob.printA();
}
}

2.4 访问权限
(1) 使用在成员变量和成员方法之前的访问控制符

成员访问控制符
含 义
private
只能在类的内部被访问
public
能被所有的类访问
缺省(friendly)
只能被同一个包中的类访问
protected
可以被同一包中的类或其他包中的子类访问

(2) 使用在类之前的访问控制符

类访问控制符
含 义
public
能被所有的类使用
缺省(friendly)
只能被同一个包中的类使用

3 类的继承和接口

3.1 类的继承
一个类可以通过关键字extends继承另一个类，被继承的类称为父类，而继承的类称为子类。子类可以继承父类所有的非私有的成员作为自己的成员。

/*ExtendsDemo.java*/
class ExtendsDemo1{
int x=8;
private int y=9;
public double z=10;
void pntout(String s){
System.out.println(s);
}
}
class ExtendsDemo2 extends ExtendsDemo1{
float w=100.0f;
}
public class ExtendsDemo{
public static void main(String args[]){
ExtendsDemo2 abc=new ExtendsDemo2();
System.out.println(abc.x);
System.out.println(abc.z);
System.out.println(abc.w);
abc.pntout("你好，朋友！");
}
}

3.2 重写与关键字super
假如子类定义了与父类中完全相同的方法，则称在子类中重写或覆盖了父类的方法，假如子类定义了与父类中完全相同的变量，则称在子类中隐藏了父类的变量。
通过关键字super可以在子类中访问被隐藏的父类的变量。
super()可以调用父类的构造方法。
与this关键字同样，也只能在实例方法中使用super关键字。

/*SuperDemo.java*/
class SuperDemo1{
String name="玲玲";
int age=18;
long tel=66666666;
}

class SuperDemo2 extends SuperDemo1{
String name="张三"; //与父类的成员变量同名
int age=30; //与父类的成员变量同名
long tel=88888888; //与父类的成员变量同名
void SuperDemo2(){ //成员方法
name=super.name; //引用父类的成员变量
age=super.age; //引用父类的成员变量
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
System.out.println("电话：" + tel);
}
}

public class SuperDemo{
public static void main(String args[]){
SuperDemo2 abc=new SuperDemo2();
abc. SuperDemo2();
}
}

3.3 final类和abstract类
用关键字final修饰的类称为最终类，即不能派生子类。
用关键字final修饰的变量称为最终变量，必须在声明时赋予初始值，使用中不能修改。

用关键字abstract修饰的方法称为抽象方法，抽象方法没有方法体。
包具有抽象方法的类就是抽象类，抽象类必须用关键字abstract加以修饰。
抽象类不能创建对象，但可以派生子类。

3.4 接口
关键字interface用来声明一个接口，通过关键字implements来实现接口。
接口体中的所有方法都是抽象方法，所有的属性都默认为static，且都默认为public。
在Java中一个类只能继承一个父类，但可以实现多个接口。
实现一个接口必须实现接口中的所有抽象方法，哪怕是空实现。

/*AbstractDemo.java*/
interface AbstractDemo2{
int aa=100;
float ab=100.0f;
void pntout(String ss); //抽象方法
}
class AbstractDemo1 implements AbstractDemo2{ //实现一个接口
public void pntout(String ss){
System.out.println(ss); //实现接口中的抽象方法
}
}
public class AbstractDemo{
public static void main(String args[]){
AbstractDemo1 abc=new AbstractDemo1();
System.out.println(abc.aa);
System.out.println(abc.ab);
abc.pntout("I am a teacher.");
}
}

4 包与import语句
在Java中，包指的是接口和类的集合，这些接口和类根据功能的不同，被分别放在不同的包中。包结构的表达方法与目录结构类似，但采用域名表达法，即用点“.”代替“\”。
包的创建使用package语句，它在当前目录下创建指定的包，并将编译后的类文献放入指定的包中。
为了在其他的包中使用所定义的类，必须使用import关键字导入要使用的类。
java.lang包是java语言的核心类库(System类和String类均在该包中)，系统会自动导入该包中所有的类(import java.lang.*)。

4.1 package语句

/*Class10.java*/
package Mypack.pack1; // 建立用户自己的类库
public class Class10{ // Class10修饰为public表达能被所有的类访问
public void hi(){
System.out.println("Hi~~~~");
}
}

/*Class11.java*/
import Mypack.pack1.Class10; // 使用用户自己的类库
public class Class11{
public static void main(String[] args){
Class10 ob=new Class10();
ob.hi();
}
}

4.2 import语句
Java程序不仅可以运用本程序中定义的类，还可以通过import语句引入Java提供的类。

/*Class12.java*/
import java.util.Date; // 使用Java的类库
public class Class12{
public static void main(String[] args){
Date d=new Date();
System.out.println(d);
}
}

5 String类

5.1 字符串变量
(1) 字符串变量的创建
字符串变量的创建重要有两种：
String str1="I am a teacher";
或
String str2=new String("I am a teacher ");

/*StringDemo.java*/
public class StringDemo{
public static void main(String args[]){
String str1="I am a student";
System.out.println(str1);
String str2=new String(str1);
System.out.println(str2);
String str3=new String("I am a student");
System.out.println(str3);
String str4=new String();
str4="I am a teacher";
System.out.println(str4);
}
}

(2) 字符串和字符数组的关系
可以通过字符数组来创建一个字符串变量：
char chr[]={'t', 'e', 'a', 'c', 'h', 'e', 'r'};
String str=new String(char);

/*StringArrayDemo.java*/
public class StringArrayDemo{
public static void main(String args[]){
char chr[]={'t', 'e', 'a', 'c', 'h', 'e', 'r'};
System.out.println(chr);
System.out.println(chr[3]);
String str1=new String(chr);
System.out.println(str1);
String str2=new String(chr,0,3);
System.out.println(str2);
System.out.println(str1.length());
System.out.println(str2.length());
}
}

5.2 String类的方法
String类的常用方法
public int compareTo(String anotherString)
比较当前字符串与anotherString的大小。若当前字符串大，则返回正整数；若当前字符串小，则返回负整数；若相等，则返回0。
public boolean startsWith(String prefix)
测试当前字符串是否以指定字符串prefix开始。
public boolean endsWith(String suffix)
测试当前字符串是否以指定字符串suffix结尾。
public boolean equals(Object anObject)
将当前字符串与指定的对象anObject比较。若对象内容相同返回true，否则返回false。
public int indexOf(int ch)
从当前字符串中查找指定字符ch，返回其初次出现处的索引。若找不到，则返回-1。
public int indexOf(int ch, int fromIndex)
从当前字符串中formIndex处开始查找指定字符ch，返回其初次出现处的索引。返回结果同(9)。
public int indexOf(String str)
从当前字符串中查找指定字符串str，返回其初次出现处的索引。返回结果同(9)。
public int indexOf(String str, int fromIndex)
从当前字符串中formIndex处开始查找指定字符串str，返回其初次出现处的索引。返回结果同(9)。
public int length()
返回当前字符串的长度(字符个数)。
public String replace(char oldChar, char newChar)
将当前字符串中的oldChar字符替换为newChar字符。
public String substring(int beginIndex)
返回当前字符串中从beginIndex开始至串尾的一个子字符串。
public String substring(int beginIndex, int endIndex)
返回当前字符串中从beginIndex开始至endIndex-1处的一个子字符串。
public String trim()
去掉当前字符串的前后空格。
public static String valueOf(基本数据类型)
将数值转换为字符串。
public String toLowerCase()
将字符串转换为小写形式。
public String toUpperCase()
将字符串转换为大写形式。

5.3 数据类型的转换
(1) 字符串转换为数值
字符串转换为数值的方法
public static int parseInt(String s)

将字符串转换为int型。
public static double parseDouble(String s)

将字符串转换为double型。
public static long parseLong(String s)

将字符串转换为long型。
public static byte parseByte(String s)

将字符串转换为byte型。
public static short parseShort(String s)

将字符串转换为short型。
public static float parseFloat(String s)

将字符串转换为float型。

这些方法分别属于Integer、Double、Long、Byte、Short和Float类。
转换时要注意转换的可行性。

/*StringToNumber*/
public class StringToNumber{
public static void main(String args[]){
System.out.println(Float.parseFloat("12.34"));
System.out.println(Integer.parseInt("123456"));
System.out.println(Long.parseLong(""));
System.out.println(Byte.parseByte("123"));
System.out.println(Short.parseShort("1234"));
System.out.println(Double.parseDouble("12.3456"));
}
}

(2) 数值转换为字符串
通过使用各数值类的toString()方法，可以将数值转换为字符串：
public static String toString(基本数据类型)

/*NumberToString*/
public class NumberToString{
public static void main(String args[]){
System.out.println(Float.toString(12.34f));
System.out.println(Integer.toString(123456));
System.out.println(Long.toString());
System.out.println(Double.toString(12.3456));
byte x1=5;
System.out.println(Byte.toString(x1));
short x2=6;
System.out.println(Short.toString(x2));
}
}