Java_面向对象

---

Java是面向对象程序设计语言，java语言提供了定义类、成员变量、方法等基本的功能。类可被认为是一种自定义的数据类型，可以使用类来定义变量，所有用类来定义的变量都是引用变量，它们将会引用到类的对象。类用于描述客观世界里某一类对象的共同特征，而对象则是类的具体存在，java程序使用类的构造器来创建该类的对象。 Java也支持面向对象的三大特征：封装、继承和多态，java提供private、protected和public三个访问控制修饰符来实现良好的封装，提供extends关键字来让子类继承父类，子类继承父类可以继承父类的成员变量和方法，如果访问控制允许，子类对象可以直接调用父类里定义的方法。继承和组合具有相同的功能。使用继承关系来实现复用时，子类对象可以直接赋给父类变量，这个变量具有多态性，编程更加灵活；而利用组合关系来实现服用时，则不具备这种灵活性。 构造器用于对类实例进行初始化操作，构造器支持重载，如果多个重载的构造器里包含了相同的初始化代码，则可以把这些初始化代码放置在普通初始化里完成，初始化块总在构造器执行之前被调用。除此之外，java还提供了一种静态初始化块，静态初始化块用于初始化类，在类初始化阶段被执行，如果继承树里的某一个类需要被初始化时，系统将会同时初始化该类的所有父类。

5.1类和对象

前言
java是面向对象程序设计语言，类是面向对象的重要内容，可以把类当成一种自定的类型可以使用类来定义变量，这种类型的变量统称为引用变量。也就是说，所有类是引用类型。
面向对象的程序设计过程中有两个重要概念：类（class）和对象（object，也被称为实例，instance），其中类是某一批对象的抽象，可以把类理解成某种概念；对象才是一个具体存在的实体。

5.1.1 定义类

java语言里定义类的简单语法
｛修饰符｝class 类名｛
零个多个构造器定义
零个多个成员变量
零个多个方法
｝
note：
构造器是一个类创建对象的根本途径，如果一个没有构造器，这个类通常无法创建实例，因此Java语言提供了一个功能；如果程序员没有为一个类编写构造器，则系统会为该类提供一个默认的构造器。一旦程序员为一个类提供了构造器，系统将不再为该类提供构造器。

含有默认构造器的代码

在这public class Person {
   
	String name;
	int age;
}
public class PersonTest {
   
	public static void main(String[]args) {
   
		Person p=new Person();
		System.out.println(p.age );
	}
}
//自定义的构造器
public class Person {
   
	String name;
	int age;
public Person(String name,int age) {
   
	this.age=age;
	this.name=name;
}
}`

public class PersonTest {
   
	public static void main(String[]args) {
   
		Person p=new Person("ad",2);
		System.out.println(p.age );
	}

}

5.1.2 对象的产生和使用

创建对象的根本途径是构造器，通过new关键字类调用某个类的构造器即可创建这个类的实例。

//使用Person类定义一个Person类型的变量
Person p;
//通过new关键字调用Person类的构造器，返回一个Person实例
//将该Person实例赋给p变量
p=new Person();
//上面代码也可简写成如下形式
//定义p变量的同时并为p变量赋值
//Person p=new Person();
java
在这里插入代码片

创建对象后大致有如下作用。
1️⃣访问该对象的实例变量
2️⃣调用对象的方法
note
如果访问权限允许，类里定义的方法和成员变量都可以通过类或实例来调用。类或实例访问或成员变量的语法是：类.类名|方法，在这种方式中，类或实例是主调者，用于访问该类或该实例的成员变量或方法。
static修饰符的方法和变量，即可通过类来调用，也可通过实例来调用；没有使用static修饰的普通方法和成员变量，只可通过实例来调用。

在这里插入代码片
//访问p的name实例变量，直接为该变量赋值
p.name="李刚"；
//调用p的say（）方法，声明say（）方法时定义了一个形参
//调用该方法必须为星璀璨指定一个值
p.say("java语言很简单，学习很容易")；
//直接输出p的name实例变量，将输出李刚
System.out.println(p.name);

5.1.3 对象、引用和指针

在前面PersonTest.java代码中，有这样一行代码：Person p=new Person();
这行代码创建了一个Person实例，也被称为Person 对象，这个Person对象被赋给P变量。
这行代码中实际产生了两个东西：一个是p变量，一个是Person对象
从Person类定义来看，Person对象应包含两个实例变量，而变量是需要内存存储的，因此，当创建Person对象时，必然需要有对应的内存来存储Person对象的实例变量.

类也是一种引用数据类型，因此程序中定义的Person类型的变量实际上是一个引用，它被存方法在栈内存里，指向实际的Person对象；而真正的Person对象则存放在堆内存中，下面显示引用变量的示意图。

栈内存里的引用变量并未真正存储对象的成员变量，对象的成员变量数据实际存放在堆内存里；
而引用变量只是指向该堆内存里对象。从这个角度来看，引用变量与C语言里的指针很像，他们都是存储一个地址值，通过这个地址来引用到实际对象，实际上java里面的引用就是C里的指针，只是java语言把这个指针封装起来，避免开发者进行繁琐的指针操作。
当一个对象被创建成功以后，这个对象将保存在堆内存中，java程序不允许直接访问堆内存中的对象，只能通过该对象的引用操作该对象。也就是说，不管是数组还是对象，都只能通过引用来访问它们。

5.1.4对象的this引用

this关键字总是指向调用该方法的对象。this出现的位置不同作为对象的默认引用有两种情形。
1️⃣构造器中饮用该构造器正在初始化的对象
2️⃣在方法中引用调用该方法的对象

this关键字最大的作用就是让一个方法，访问该类里的另一个方法或实例变量，假设定义了一个Dog类，这个Dog对象的run()方法需要调用它的jump()方法

在这里插入代码片
public class Dog{
   
int age;
//无参构造
public Dog(){
   
}
//有参构造
public Dog(int age){
   
this.age=age;
}
public void jum(){
   
System.out.println("jump 方法正在执行");
}
public void run(){
   
this.jump();
System.out.println("run 方法正在执行");
}
}

public class DogTest{
   
public static void main(String[]args){
   

Dog d=new Dog("djh");
d.run();
}}

note
1.this关键字只能在本类或继承的子类中使用
2.静态方法不能直接访问非静态方法，所以静态方法中不能使用this关键字。
原因：对于撒台词修饰的方法而言，则可以使用类来直接调用该方法，如果在static修饰的方法中使用this关键字，则这个关键字就无法指向合适的对象，所以static修饰的方法中不能使用this引用。由于static修饰的方法不能使用this引用，所以static修饰的方法不能访问不适用static修饰的普通成员，因此java语法规定：静态成员不能直接访问非静态成员。

//示范代码

在这里插入代码片
public class StaticAccessNonStatic{
   
public void info(){
   
System.out.println("简单info方法");
｝
public static void main(String[]args){
   
//因为main（）方法时静态方法，而info（）时非静态方法
//调用main（）方法的是该类本身，而不是该类的实例
//因此省略的this无法指向有效的对象
info();
}
}

2️⃣在方法中引用调用该方法的对象情况
1.成员变量和局部变量同名时使用this关键字成员变量会覆盖掉局部变量
//示范代码

public class ThisInContructor{
   
//定义一个名为foo的成员变量
public int foo;
public ThisInContructor(){
   
//构造器里定义一个foo变量
int foo=0;
//使用this代表构造器正在初始化的对象
//下面的代码将会把构造器正在初始化的对象 foo成员变量设为
this.foo=6;
}
public static void main(String[]args){
   
//所有使用ThisInContructor创建的对象的foo成员变量
System.out.println(new ThisContructor().foo);
}

2.当this 作为对象的默认引用时，程序可以像访问普通引用变量一样来访问这个this引用，甚至可以把this当成普通方法的返回值。
//示范代码

public class ReturnThis{
   
public int age;
public ReturnThis grow(){
   
age++;
//return this 返回调用该方法的对象
return this;
}
public static void main(Stringp[]args){
   
ReturnThis rt=new ReturnThis();
rt.grow().grow();
System.out.println("rt的age成员变量值是："+rt.age);
}
}

5.2方法详解

方法时类或对象的行为特征的抽象，方法时类或对象最重要的组成部分。但从功能上看方法完全类似于传统结构化程序里的函数，值得指出的是，java里的方法不能独立存在，所有的方法都必须定义在类里。方法在逻辑上要么属于类，要么属于对象。

5.2.1 方法的所属性

不论是从定义方法的语法来看，还是从方法的功能来看，方法和函数之间有相似性。
在结构化编程语言里函数是一等公民。整个软件由一个个函数组成；
在面向对象语言中类才是一等公民，整个系统由一个个的类组成。因此在java语言里方法不能独立存在，方法必须属于类或 对象。
因此，方法只能定义在类体内定义，如果这个方法使用了static修饰则这个方法属于这个类，否则这个方法属于这个类的实例。
执行方法时必须使用类或对象 作为调用者，即所有方法都必须使用“类.方法”或“对象.方法”的形式来调用。这里可能产生一个问题：同一个类里不同方法之间相互调用时，不就可以直接调用码？这里需要指出：
同一个类的一个方法调用另外一个方法时，如果被调方法是普通方法，则默认使用this作为调用者；
如果被调用方法是静态方法，则默认使用类作为调用者。，也就是说，表面上看起来某些方法可以被独立执行。

属性主要体现在如下几个方面：
①方法不能独立定义，方法只能在类体里定义
②从逻辑意义上来看，方法要么属于该类本身，要么属于该类的一个对象
③永远不能独立执行方法，执行方法必须使用类或对象作为调用者

5.2.2 方法的参数传递机制

java里方法的参数传递方式只有一种：值传递
所谓的值传递，就是讲实际参数值的副本（复制品）传入方法内，而参数本身不会受到任何影响

//下面程序演示了方法参数传递的效果
//基本类型的参数传递

在这里插入代码片
public class PrimitiveTransferTest{
   
public static void main(String[]args){
   
//下面三行代码实现a、b变量的值交换
//定义一个临时变量来保存a变量的值
int tmp=a;
//把b的值赋给a
a=b;
//把临时变量tmp的值赋给a
b=tmp;
System.out.println("swap方法里么，a的值是"+a+":b的值是"+b);
｝
public static void main(String []args){
   
int a=6;
int b=9;
swap(a,b);
System.out.println