调用过程中参数是通过实参向形参传值的。
这里我看书上给了一个传值的过程图，看着略显复杂，其实真的不难理解！
这里引入了一个堆栈的概念：（主调方法为实参赋值，将实参值存放到内存中专门存放临时变量的区域中。这块存储区域称为堆栈。）
3.3.3 方法重载
方法重载是指多个方法享有相同的名字，但这些方法的参数必须不同，或者是参数的个数不同，或者是参数的类型不同，返回类型不能用来区分重载的方法。
这里如果单纯地看这段文字多少有些干涩，我们通过一个例子来理解：
举例：（两个数求和）
public class Tester {
public static void main(String[] args) {
Tools t = new Tools();
int x0 = t.add(3,5);
System.out.println(“参数个数为2时，和为” + x0);
int x1 = t.add(3,5,6);
System.out.println(“参数个数为3时，和为” + x1);
}
}
public class Tools {
int add(int a , int b) //参数个数为2
{
return a + b;
}
int add(int a,int b,int c) //参数个数为3
{
return a + b + c;
}
}
此时运行结果如图：
通过单步调试我们会发现，程序运行时会根据我们参数的个数在相同名字的方法里选择合适的一个！！
重载使得程序的实现方式变得很简单，只需要一个方法名，就可以根据不同的参数个数选择该方法的不同版本。
3.3.4 构造方法
构造方法是一个特殊的方法，主要用于初始化新创建的对象。构造方法的方法名要与类名相同，且无返回值。
注意：这里说的构造方法无返回值，并不是要在构造方法名前加上void ，构造方法名是不能有void的，如果在构造方法名前加了void，系统就不会自动调用该方法了。
一个类可以创建多个构造方法，当类中包含多个构造方法时，将根据参数的不同来决定要用哪个构造方法来初始化新创建对象的状态，达到方法重载的目的。
举例：（求长方形的面积）
public class Rectangle {
int width,length;
Rectangle(){ //构造方法，没有参数，方法名与类名相同
length = 2;
width = 2;
}
Rectangle(int len,int wid){ //构造方法，带有参数
length = len;
width = wid;
}
int getArea()
{
return length*width;
}
}
public class Tester {
public static void main(String[] args) {
Rectangle rect_1 = new Rectangle();
Rectangle rect_2 = new Rectangle(6,4); //应用构造方法创建实例对象
int area_1 = rect_1.getArea();
int area_2 = rect_2.getArea();
System.out.println(“长方形的面积为：” + area_1);
System.out.println(“长方形的面积为：” + area_2);
}
}
运行结果：
&&：在一个类的程序中，也可以没有定义构造方法，则Java系统会认为是定义了一个缺省构造方法，缺省构造方法是无任何内容的空方法。当编写类时，只有在需要进行一些特别初始化的场合，才需要定义构造方法。
直接给一个书上的例子：
/缺省构造方法构造长方体类/
class Box
{
double width,height,depth;
double volume() //计算长方体体积
{
width = 10;
height =10;
depth =10;
return widthheightdepth;
}
}
public class Example
{
public static void main(String[] args)
{
Box box = new Box; // 应用缺省方法创建实例对象
double v;
v = box .volume();
System.out.println(“长方体体积为：” + v);
}
}
3.4 对象
通过前面我们知道类是一个抽象的概念，而对象是类的具体化。
一个对象的生命周期包括三个阶段:创建、使用和释放。
需要注意的是：对象是引用类型，因此，对象名这个变量，其值是一个长整型（代表了另外一个内存单元的首地址）。对象实体对应的内存在首地址指向的另一地方。
类名 对象名 = new 类名([参数列表])
这一表达式隐含三部分：对象声明 实例化 初始化
/对象声明/
类名 对象名;
/实例化/
对象名 = new 构造方法();
2.对象的使用
访问对象成员变量的格式：
对象.成员变量;
调用对象成员方法的格式：
对象名.方法名([参数列表]);
3.5 面向对象特性
Java语言中有三个典型的面向对象的特性：封装性、继承性、多态性。
3.5.1 封装性
封装性就是把对象的属性和服务结合成一个独立的相同单位，并尽可能隐蔽对象的内部细节。
在Java语言中，对象就是对一组变量和相关方法的封装，其中变量表明了对象的态度，方法表明了对象具有的行为。通过对象的封装，实现了模块化和信息隐蔽。
1.修饰符
为了对类对象封装，通过对类成员修饰符 施以一定的访问权限，从而实现类中成员的信息隐藏 。
类体定义的格式：
class 类名
{
[变量修饰符] 类型 成员变量名;
[方法修饰符] 返回类型 方法名(参数){…}
}
2.访问权限的限定
在类体成员定义的修饰符可选项中，提供了4种不同的访问权限。它们是private、default、protected 和 public。
- private
在一个类中被限定为private的成员，只能被这个类本身访问，其他类无法访问。如果一个类的构造方法声明为private，则其他类不能生成该类的一个实例。
- default
在一个类中不加任何访问权限限定的成员属于缺省的(default)访问状态，可以被这个类本身和同一个包中的类所访问。
- protected
在一个类中被限定为protected的成员，可以被这个类本身、它的子类(包括同一个包中以及不同包中的子类)和同一个包中的所有其他的类访问。
- public
在一个类中限定为public的成员，可以被所有的类访问。
3.5.2 继承性
继承性是面向对象程序中两个类之间的一种关系，即一个类可以从另一个类继承状态和行为。
被继承的类称为父类（超类），继承的类称为子类。
Java不支持多重继承！！！
1.子类的定义
class 父类
{
…
}
class 子类 extends 父类
{
…
} //继承实现了代码复用
举例：
这里我们以同时输出老师和学生的信息为例：
//原始思路:定义老师和学生两个类和各自的信息，主类调用输出
//利用继承思路：我们定义一个公共的Person类，用老师和学生的类继承该Person类
代码展示：
//Tester.java
public class Tester {
public static void main(String[] args) {
Teacher t = new Teacher();
Student s = new Student();
t.name = “张老师”;
t.age = 35;
t.mobile = “15571569574”;
t.Output();
s.name = “李小华”;
s.age = 20;
s.mobile = “17255617524”;
s.Output();
}
}
//Person.java
public class Person {
String name;
int age;
String mobile;
void Output()
{
System.out.println(“全部信息为:” + name + “-” + age + “-” + mobile);
}
}
//Teacher.java
public class Teacher extends Person { //继承Person类
}
//Student.java
public class Student extends Person { //继承Person类
}
运行截图：
分析：从上面的这个例子不难看出，当我们在某些类中有相同的操作，比如输出相同的信息，我们不需要逐个类进行操作，可以给这些类一个父类，让它们继承父类的属性，这样一来就减少了代码量，提高工作效率。
创建子类对象时，Java虚拟机首先执行父类的构造方法，然后再执行子类的构造方法。
从本程序的运行结果可以看出：
(1)父类的构造方法也会被子类继承，且Java虚拟机首先执行父类的构造方法。
(2)在多继承的情况下，创建子对象时，将从继承的最上层父类开始，依次执行各方法。
2.成员变量的隐藏和方法的重写
子类通过隐藏父类的成员和重写父类的方法，可以把父类的状态和行为改变为自身的状态和行为。
calss A //父类
{
int x;
void setX(){
x = 0;
}
}
class B extendas A //子类
{
int x; //隐藏父类的变量x
void setX(){ //重写父类的方法，此时将调用子类自己的方法
x = 5;
}
}
3.super关键字
关键字super用来实现对父类成员的访问。
三种使用情况：
-
访问父类被隐藏的成员变量或者方法。
-
调用父类中被重写的方法
-
调用父类的构造方法
4.this关键字
this表示某个对象，可用于构造方法和实例方法，但不能用于类方法。
-
用于构造方法时，代表调用该构造方法所创建的对象
-
用于实例方法时，代表调用该方法的当前对象
this.当前类的成员方法();
或者
this.当前类的成员变量
public class A {
int x = 100;
A(){
this.x = 1000;
}
A(int a){
this.x = 10000;
}
}
public class Tester {
public static void main(String[] args) {
A a = new A();
A aa = new A(88);
System.out.println(a.x); //输出结果为1000
System.out.println(aa.x); //输出结果为10000
}
}
3.5.3 多态性
多态是指一个程序中同名的方法共存的情况，有时需要利用这种重名的现象来提供程序的抽象性和简洁性。
在Java中，多态性体现在两个方面，由方法重载实现的静态多态性和方法重写实现的动态多态性。
3.5.4 其他修饰符的用法
（1）final关键字
可放到类、成员变量、方法前面，限定它们。
a. final int X=100; // 放到成员变量的类型前面， 定义一个常量X
b. final int add(int a, int b){ … } //放到方法声明前面，此方法不能被子类重写
c. final class Person{ … } //放到class前，此类不能被继承，只能独立使用此类
（2）static关键字
在java语言中，成员变量和成员方法可以进一步分为两种：类成员和实例成员。
用关键字static修饰的变量或方法称为类变量和类方法。反之称为·实例变量或实例方法。
static 类型 变量名；
static 返回类型 方法名（参数）
{
.
.
.
}
如果在声明的时候用static来修饰，则声明的是静态变量和静态方法。
调用时不需要实例化！！！！
（3）类成员与实例成员的区别
可以将 类变量、类方法，看作是该类的所有对象（一个类，可以new出多个对象出来）共享使用的。
实例变量、实例方法则不同，由一个类new出多个对象，每个对象有自己的变量、方法，互不干扰、互不“来往”。
（4）abstract关键字（抽象类）
用abstract修饰一个类的时候，这个类叫做抽象类。
abstract class 类名 //定义抽象类
{
成员变量；
方法（）； //定义普通方法
abstract 方法（）； //定义抽象方法
}
抽象类是专门设计用来让子类继承的类！
抽象类的特点总结如下：
-
类体中，可以定义普通方法，也可以定义抽象方法；也可以只有普通方法，没有抽象方法；也可以只有抽象方法，没有普通方法；
-
抽象类中的抽象方法是只有方法声明，没有代码实现的空方法；
-
抽象类不能被实例化；
-
若某个类包含了抽象方法，则该类必须被定义为抽象类；
3.6 接口
3.6.1 接口的定义
接口是抽象类的一种，只包含常量和方法的定义，而没有变量和具体方法的实现，且其方法都是抽象方法。
接口的用处：
-
通过接口实现不相关类的相同行为，而无需考虑这些类之间的关系；
-
通过接口指明了多个类需要实现的方法；
-
通过接口了解对象的交互界面，而无需了解对象所对应的类。
[public] interface 接口名 [extends 父接口名]
{
.
.
.
}
说明：接口可以多重继承 ------ 一个接口可以继承多个接口，接口之间逗号分隔。
3.6.2 接口的实现
接口必须是由类来实现（换句话说，类会使用接口—在声明中，用implements语句实现接口，一个类可以实现多个接口，逗号分隔多个接口）
例如：已定义接口 IPrintable, IBrowserable, IShowable, 当某个类要实现这3个接口时，语法为： public class Article implements IPrintable, IBrowserable, IShowable { … }
接口中就相当于定义了一套规则—>定义功能（空方法），那些实现接口的类，根据自己的需要来对每个规则进行填充（代码）！
3.6.3 接口的应用
这里我们定义一个报警接口，调用此接口实现报警门和报警灯。
public interface Alarm1 { //报警接口
public void Alarm(); // 抽象方法
}
public class Alarmdoor implements Alarm1{ //实现接口的报警门类
public static void main(String[] args) {
Alarmdoor door = new Alarmdoor();
door.Alarm();
}
public void Alarm() { //编写接口抽象方法的具体代码
System.out.println(“门报警，滴滴滴滴。。。。”);
}
}
public class Alarmlight implements Alarm1{ //实现接口的报警灯类
public static void main(String[] args) {
Alarmlight light = new Alarmlight();
light.Alarm();
}
public void Alarm() {
System.out.println(“灯亮了，闪闪闪闪。。。”);
}
}
3.7 包
包的作用：用来管理类。 想想C语言中的 math.h , stdio.h 这些头文件。我们一看就能知道，math.h 中肯定提供了很多跟数学运算有关的函数； stdio.h 中肯定提供了跟 I/O操作有关的函数。
3.7.1 java系统包
同样地，Java中，通过包来管理一些相关的类。例如，Java中常用的系统包定义如下。通过包来分门别类管理所有的类。如果我们编程时需要使用到系统的包，就必须通过import导入到当前类文件中。
3.7.2 用户自己创建包
在类的第一行语句，使用package 包名; 语句来定义自己的包。例如：
package course.wsyu.edu.cn; //只能在源码文件的最上面
public class Student{ // 学生类归于包 course.wsyu.edu.cn
…
}
3.7.3 包的引用
最后
接口的报警灯类
public static void main(String[] args) {
Alarmlight light = new Alarmlight();
light.Alarm();
}
public void Alarm() {
System.out.println(“灯亮了，闪闪闪闪。。。”);
}
}
3.7 包
包的作用：用来管理类。 想想C语言中的 math.h , stdio.h 这些头文件。我们一看就能知道，math.h 中肯定提供了很多跟数学运算有关的函数； stdio.h 中肯定提供了跟 I/O操作有关的函数。
3.7.1 java系统包
同样地，Java中，通过包来管理一些相关的类。例如，Java中常用的系统包定义如下。通过包来分门别类管理所有的类。如果我们编程时需要使用到系统的包，就必须通过import导入到当前类文件中。
3.7.2 用户自己创建包
在类的第一行语句，使用package 包名; 语句来定义自己的包。例如：
package course.wsyu.edu.cn; //只能在源码文件的最上面
public class Student{ // 学生类归于包 course.wsyu.edu.cn
…
}
3.7.3 包的引用
最后
[外链图片转存中…(img-bh8TCyzd-1714384056232)]
[外链图片转存中…(img-LRsRhOeR-1714384056232)]
[外链图片转存中…(img-ORg4fAyc-1714384056233)]
458
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
