面向对象的概念

JAVA里有一个非常重要的特性，那就是面向对象，什么是面向对象呢？下面我们举个例子

平常我们需要遍历数组的时候，都是先这样：

定义数组int[] array = new int[] {10,20,30} ;

for循环遍历for(int i=0;i<array.length-1;i++)

对吧

不过我告诉你现在可以不用写这么复杂的语句了

你只需要调用jdk写好的方法即可

比如题目需要让你遍历数组，且输出格式为[10,20,30]

按照以前的方法，你肯定想到的是这个：

int[] array = new int[]{10,20,30};
System.out.print("[");						//打印第一个中括号，删掉ln表示不换行
for(int i=0;i<array.length-1;i++){
    if(i==array.length-1){
        System.out.println(array[i]+"]");	//判断最后一个字符并改变格式为数字+]
    }
    else{
            System.out.print(array[i]);		//否则持续遍历数组
        }
}

不不不，

你只需要两行代码：

int[] array = new int[]{10,20,30};

System.out.println(Arrays.toString(array));

系统自动在类外面创建一个import java.util.Arrays;来补充输出，

使得你写这句话与写上面那一串代码的输出结果是相同的

这就引出了两个不同的概念：

面向过程和面向对象

前者就像是奋力写代码的你，什么功能都得需要自己去写，写错一点可能就完蛋

后者就像是偷懒的你，有人已经写了这个方法了？好哒，我就拿来用啦～

举个例子吧

例如玩游戏吧，最接近生活的例子╰(°▽°)╯：

面向过程：这个游戏的代码都需要你自己去写，大到建模和交互，小到贴图和bgm，你都得自己亲历亲为

​ 结果你35岁头发就和你say bye bye了

面向对象：哎，这有个LOL，看周围人玩的挺好，我也下载玩一玩吧～

​ 同样35岁，你已经是一名职业选手了

可能有点极端，不过差不多就是这种感觉💥

​

​

类与对象

定义

既然都面向对象了，接下来该说下类和对象的定义了

类： 是一类事物相关属性和行为的集合，可以看作是一类事物的模板

对象： 是一类事物的具体展现，对象是类的一个实例，必然具备该事物的属性和行为

例如手机这个具体的对象是由手机设计图这个类根据设计图里面的长，宽，高等属性做的，而它能打电话，发短信，玩游戏这一类的行为是根据类里面的行为做的，那手机设计图就是类，根据设计图做出来的手机就是具体的对象

再说的简单点，世界上定义了一种类：人，你就是人这个类中的一个对象，世界定义人这个类可以吃饭、睡觉，那你如果是这个类中的对象的话，必然也可以吃饭睡觉

好了，讲完了概念，我们来写点代码比划比划

类的内容：

//定义一个类
public class student{/*以下代码内容均在这里*/}    //定义一个学生类①

//添加属性定义：
int age;		//年龄
String name;	//名字

//类中的方法定义：
public void eat() {
    System.out.println("吃饭的方法执行啦！");	  //定义一个吃的方法
}
public int say_num(){
    return 10;		// 定义一个调用方法就返回数字的方法
    				//这个方法固定返回10
}

稍微讲一下

定义类的格式这里统一为：

public  class  定义类的名字{    

		//代码内容

}

类有属性，这里我们是定义了一个学生，那当然，学生肯定有年龄和名字吧

那就像平常定义变量一样，写下

int age = 18；//定义属性：年龄

String name = “王小明”； //定义名字：用字符串

好了，学生还能干什么呢？

那肯定是学习吧

public void study(){  //框架先写好
    //代码内容
}	

我们给他一个简单的输出:System.out.prinln("开始学习！")；

代码如下：

public void study(){
	System.out.prinln("开始学习！")；
}

---

使用

紧接着就是使用啦～

首先我们先在同一个包里创建一个java类，命名为running.java

写上基础的main函数，等会拿他运行

这里假设你是用的我上面创建的学生类，这个类的名字就叫Student.java吧

这两个文件属于同级，如下所示：

Project
    |
​	|-----Student.java
    |
​	|-----running.java

首先我们得先在running.java文件中的main函数里创建一个对象

创建对象有一个固定格式：

类名称 对象名称 = new 类名称（）；

那还是拿我上面的学生类举例创建，代码如下

Student li =new Student();

这样你就根据一个Student类创建了一个对象li啦

哎，你是不是觉得就创建了两个文件嘛，怎么关联嘛？

不急不急，你先给我写一段代码：

System.out.println(stu.name);// 参数调用

写完运行主函数试试

是不是输出了你刚刚写在Student这个类中的名字？//王小明

你看这就是打印了类中的参数

未完待续，太困了睡觉去······

------2021/08/06 23：48-------

​

JAVA三大基本特征

接下来我们就说说Java的面向对象有三大特征：封装、继承和多态

封装

三大特征里最简单的一种，一般我们使用的的方法，或者下面使用的private就是封装，

所谓封装，也就是将代码实现的一些细节隐藏起来，需要使用这个方法时不需要重新编写此方法的具体细节，实现“拿来就用”（当然就是方便懒人啦～）

以下是引用的菜鸟教程的封装概念：

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的接口控制。
封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

--菜鸟教程

​

​

使用封装定义一个标准类

好了，既然你已经会了类的基本定义与使用，那我们就用封装来练习写一个标准的手机类吧

不过定义之前我还得给你讲些小的代码片段

1. private私有的
2. get，set方法

好的，我们一个一个说：

先说private私有的

这个与一开始我们写的public属于相反的意思，public为公有的，所有人都可以调用它

private为私有的，只有本类才能使用，

来一段代码：

public class Phone(){			//定义一个手机类
	private int Price=4999;		//定义一个未公布价格的手机
    String name="苹果";		   //名字肯定都知道了
}

现在有一个没有发布的手机，它的起售价格是4999元，知道的只有你和我，但他的牌子是很多人知道的“苹果”，为什么很多人知道呢？因为可以在主函数里调用查看：

Phone phone=new Phone(); //实例化一个手机对象

System.out.println(phone.name); //输出name

输出后就是大名鼎鼎的“苹果”了

但是有人想用这个方法获取只有你我才知道的价格，

他写了一行：System.out.prinln(phone.Price);

报错了

这就是私有化参数——Price【价格】

不过到了该发布的时候，你写了代码想公布来着，发现自己也调用不了

这又是为什么呢？

哎，这又要讲到需要给你补充的第二个代码片段了：get，set方法

直接上代码【以下为价格的标准写法】：

public void setPrice(int Price){
	this.Price=Price;		/*这里指把私有化的Price传递到这个SetPrice方法里，
											相当于倒手*/
}
public int getPrice(){
	return Price;						//设置返回值为返回Price所存的值
}

这里应该看的出来，所谓set就是修改里面的参数或者可以说往里传参数

所谓get就是获取类里的参数

那这写法怎么理解呢？

set方法：

首先public是固定的；传参不需要返回值，第二个单词写void(空类型)，

set那个是固定写法，打个比方，例如我要修改名字，你需要这么写：setName， set后面那个需要修改的参数首字母是大写的，以便区分

后面括号里写你要修改的参数，这里我要修改int类型的Price，

大括号里面统一写this.需要修改的参数名称=参数名称，例如这里的：this.Price=Price;

get方法

public是固定的，获取参数需要传参，看到这里需要传int整型，于是写int

大括号了就没什么需要讲的啦，返Price就写return Price，返回谁就写return 谁

---

知道意思就好了，我们来用用它们

新建一个.java文件，起名为running2，写main函数

前提：1. 疫情来袭，手机部件提高价格，导致整部手机价格提高，临时改变为5999

​ 2. 改为5999后公布5999的价格

public static void main (String[] args){
	Phone iphone =new Phone;		//根据phone类创建一个叫iphone的对象
    
    iphone.setPrice(5999);			//更改手机价格为5999
    System.out.println(iphone.getPrice());	//使用get方法获取价格
}

贴个完整代码

Phone类：

public class Phone(){			//定义一个手机类
   private int Price=4999;		//定义一个未公布价格的手机
   String name="苹果";		   //名字肯定都知道了
   
   public void setPrice(int Price){
   	this.Price=Price;				
   }
   public int getPrice(){
   	return Price;						
   }
   
}

主函数main

public class demo(){
   public static void main(String[] args){
   	Phone iphone =new Phone;		
   
   	iphone.setPrice(5999);			
   	System.out.println(iphone.getPrice());	
   }
}

​

​

​

​

​

​

​

---

三大特性之二：继承

java中的继承

上次我们讲了Java的三大特性之一的封装，封装其实简单理解就是打包

而这一次的继承又一些不一样

继承是面向对象的三大特征之一。继承和现实生活中的“继承”的相似之处是保留一些父辈的特性，从而减少代码冗余，提高程序运行效率。

Java中的继承就是在已经存在类的基础上进行扩展，从而产生新的类。已经存在的类称为父类、基类或超类，而新产生的类称为子类或派生类。在子类中，不仅包含父类的属性和方法，还可以增加新的属性和方法。

Java 中子类继承父类的语法格式如下：

   修饰符 class 子类名称 extends 继承的父类名称 
		{    
			// 类的主体
		}

​

​

下面是例句:

public class Student extends Person{}

Java 的继承通过 extends 关键字来实现，extends 的英文意思是扩展，而不是继承。extends 很好的体现了子类和父类的关系，即子类是对父类的扩展，子类是一种特殊的父类。从这个角度看，使用继承来描述子类和父类的关系是错误的，用扩展更恰当。

那么为什么国内把 extends 翻译为“继承”呢？子类扩展父类之后就可以获得父类的属性和方法，这与汉语中的继承（子辈从父辈获得一笔财富称为继承）具有相似性。

那我们开始写点代码使用下继承的特性:

首先我们定义一个Person类,他作为接下来这个子类的父类,代码如下:

public class Person{
	protected String name = "tangerine702";	//定义了一个受保护的参数
}

接下来是子类teacher,代码如下:

public class teacher extends Person{
	public String name = "t702";			//与父类不一样的参数
    
    public void text(String name){			//方法
        System.out.prinln(name);			//main方法实例化传递的参数
        System.out.prinln(this.name);		//本类定义的参数
        System.out.prinln(super.name);		//父类的参数
    }
}

main函数调用一下

public static void main(String[] args){
	teacher t1=new teacher();
	teacher.text("柑橘");
}

输出结果为：

柑橘----------------->括号传递参数name
t702---------------->teacher子类name参数
tangerine702--------父类name参数

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

实例

class Animal{
 	void eat{
 		System.out.println("动物：吃");
 	}
}
---------------------------------------------------
class Dog extends Animal{
	void eat{
		System.out.println("狗：吃");
	}
    
    void eat_extends{
        this.eat;			// this 调用自己的方法
        super.eat;			// super 调用父类方法
    }
}
---------------------------------------------------
public class extends{
    public static void main(String[] args){
        Animal a = new Animal();
        a.eat;
        Dog d = new Dog();
        d.eat_extends();
    }
}

输出结果为：

动物：吃
狗：吃   
动物：吃  

• [1] C语言中文网_Java继承（extends）简明教程 (biancheng.net) (opens new window)

• [2] Java 继承 | 菜鸟教程 (runoob.com) (opens new window)

---

上一集我们讲完了Java中的继承，这节就来讲三大特性最后的那一个

多态！

​

​

三大特性之第三特性：多态

多态这个词可能初听会有点奇怪和不理解，

但是你可以理解成：“多种形态”

简称“多态”

这样是不是就好理解多了(●ˇ∀ˇ●)

那我下面给你画张图看

 		动物[父类：Animal]
 		方法：吃(eat)
 		输出：动物在吃
 		    |
 		 	|
 	-----------------	
    |		        |
 猫(cat)			狗(dog)
 方法：吃(eat)	  方法：吃(eat)
 输出：猫吃鱼		 输出：狗啃骨头

以上的猫cat和狗dog都继承了动物这个类，且动物Animal、猫cat和狗dog都有同一名称的方法eat

在主函数中创建对象：Animal a = new cat();

输出eat方法：a.eat();

屏幕显示：吃鱼？

？？？

不是创造的Animal吗，怎么？都会吃鱼啦？

变异了不成？

哈哈哈不是的，再说你看实例化对象的时候都和之前不一样，这里变奇怪也是可能的

插句嘴，这个是方法重写，具体会在下一章细说，我们先记住要想用多态，必须有以下三点注意：

1. 一定有继承关系
2. 一定有方法重写参与
3. 左边的一定是右边的父类

好了上面动物猫狗的情况转换成代码相信你一看就懂哦

class Animal {
    void eat() {
    	System.out.println("动物在吃");
    }
}
 
class cat extends Animal {
    void eat() {
        System.out.println("猫吃鱼");
    }
}
 
class dog extends Animal {
    void eat() {
        System.out.println("狗啃骨头");
    }
}
 
 public static void main(String[] args) {

        // 多态形式，创建猫类对象
        Animal animal = new Cat();
        // 调用的是Cat的 eat
        animal.eat();

        // 多态形式，创建狗类对象
        Animal animal2 = new Dog();
        // 调用的是Dog的eat
        animal2.eat();
    }
}