Java基础之面向对象-总结

╰+哭是因爲堅強的太久メ 2024-04-17 16:59 80阅读 0赞

## 面向对象 ##

面向对象的程序设计方式：遇到一件事时，“我该让谁来做”，那个“谁”就是对象，他要怎么做这件事是他自己的事，最后一群对象合力能把事就好就行了。

**面向对象和面向过程的对比**

面向过程  
1.系统以过程/方法为中心来组织  
2.过程间相互发送数据  
3.过程的执行动作与数据被明显的分离  
4.关注的焦点在于数据结构、算法和执行步骤  
5.过程通常难以被复用

面向对象  
1.系统以对象为中心来组织  
2.对象相互间发送消息  
3.相关的属性和行为被统一到对象上  
4.关注的焦点是对象及对象的职责  
5.使得系统构建更容易，易维护，易扩展，易复用  
6.解决问题的方式更接近人的思维方式，使人更容易理解

## 类的定义 ##

类class:类就是属性和方法的结合

抽象(抽取公共的属性或方法)

对象---------汇总----------->类

对象具有的特点
    
    	1.对象具有属性和行为
    	2.对象具有变化的状态
    	3.对象具有唯一性
    	4.对象都是某个类的实例

类--------实例化(new )------->对象

**面向对象三大特性:**

封装:内部的操作 对外而言不可见,当内部的操作都不可直接使用的时候才是安全的  
继承:在已有结构的基础上继续进行功能的扩充  
多态:是在继承的基础上扩充而来的概念,指类型的转换处理

**类创建语法:**

<修饰符>  class 类名{
    		成员变量(属性)
    		成员方法(行为)
    		嵌套类(内部类)
    		代码块
    	}
    
    	类修饰符:public <default>
    
    	变量与方法的修饰符:public protected <default> private
    
    	类名命名规范:
    		帕斯卡(pascal)规则
    		首字母大写.其余单词首字母大写.

**注意:**

1.public 修饰的类名必须与java源文件的名字保持一致(区分大小写)  
2.类中仅允许定义一个public修饰的class

**使用类**

实例化
    	类名 对象名=new 构造函数();
    	例如:
    	XiyoujiRole tangseng=new XiyoujiRole();
    通过对象调用属性或方法, 用 "."的方式访问
    	例如:
    	tangseng.naili="※※※※※";
    	tangseng.hello();

**构造器(构造方法.构造函数):构造对象**

特征

1.一般用public 修饰

2.构造函数名称与类名大小一致

3.没有返回值,不能有return语句

功能:

1.完成对象的实例化  
XiyoujiRole sunwukong=new XiyoujiRole();

2.完成对象实例化的同时,对成员变量初始化  
XiyoujiRole sunwukong=new XiyoujiRole(“孙悟空”,“金箍棒”,"※※※※※","※※※※※");

注意:  
1.所有类默认带有无参构造函数

2.当定义了有参构造函数,默认无参构造函数失效,建议显示无参构造函数

**各个数据类型的默认值**  
\* byte：0  
\* long:0  
\* sort:0  
\* int:0  
\* double:0.0  
\* float:0.0  
\* char:空  
\* boolean:false

## 创建对象原理 ##

在实例化一个对象时，同时操作了栈内存和堆内存

在栈内保存对象的首地址，即引用；  
在堆内存中保存了对象的属性。  
对对象的所有操作只能通过引用完成，一旦引用出栈释放没有任何引用指向该对象，对象就变成垃圾失效。

**垃圾回收机制**

当没有对象引用指向原先分配给某个对象的内存时，该内存便成为垃圾。  
JVM的一个系统级线程会自动释放该内存块。  
垃圾回收机制作用于堆内存，与栈内存无关。  
垃圾回收机制是JVM内部运行的一个优先级比较低的后台线程，自动进行垃圾回收。它是保证程序健壮的主要手段，不用程序员参与，避免了由于程  
序员忘记回收内存而引起的内存泄漏，同时也避免了回收内存带来的代码繁琐。

## This 关键字 ##

1.代表自身

2.当前调用方法的对象

3.通常在类的方法中定义

**用this关键字注意:**  
1.方法中变量与成员变量重名  
2.在一个构造器中,调用其他重载的构造器,必须放在第一行,所带的参数决定调用哪一个构造函数  
3.返回当前对象的引用

## 封装:隐藏属性/方法 或实现的细节 ##

特点:

1.属性私有化,用private修饰

2.对外提供公共的get和set方法访问属性(访问器)  
\-----get方法取值.set方法赋值

作用:  
1.隐藏类的实现细节  
2.让使用者只能通过事先指定好的方法来访问数据,可以方便的加入控制逻辑,限制对属性的不合理操作  
3.对数据进行检查

访问权限修饰符:public private protected default  
类修饰符:public default  
类成员修饰符: public private protected default  
访问权限的大小:public>protected>default>private(最安全)

public:同类. 同包. 不同类. 不同包  
protected:同类. 同包. 不同包  
default:同类. 同包  
private:同类

代码展示

//	编写一个三角图形类，有三个属性分别代表三边长度。
    //	编写属性要求如下：
    //	边长必须为正数
    //	三个边长必须能组合成三角形（三角形任意两边和大于第三边）
    //	编写方法要求如下：
    //	对边长进行赋值
    //	输出三角形的三个边长
    //	编写主函数，对该三角图形类进行调用。
    
    public class sanjiaoxing {
    	
    	private int a;
    	private int b;
    	private int c;
    	
    
    	public int getA() {
    		return a;
    	}
    	public void setA(int a) {
    		this.a = a;
    	}
    	public int getB() {
    		return b;
    	}
    	public void setB(int b) {
    		this.b = b;
    	}
    	public int getC() {
    		return c;
    	}
    	public void setC(int c) {
    		this.c = c;
    	}
    	
    	public static void main(String[] args) {
    		sanjiaoxing sjx=new sanjiaoxing();
    		sjx.setA(5);
    		sjx.setB(4);
    		sjx.setC(5);
    		if(sjx.getA()+sjx.getB()>sjx.getC()&&sjx.getA()+sjx.getC()>sjx.getB()&&sjx.getB()+sjx.getC()>sjx.getA()) {
    			System.out.println("a:"+sjx.getA()+",b:"+sjx.getB()+",c:"+sjx.getC());
    		}else {
    			System.out.println("输入有误");
    		}
    	}

## 继承 ##

\*\*语法:<权限修饰符> class 子类(派生类) extends 父类(超类,基类)\{

\}\*\*

**特征:**

1.子类可以复用父类中所有非private修饰的属性和方法  
2.子类可以扩充自己的属性和方法  
3.降低代码的耦合度,提高代码的复用性

**注意:**  
1.Java中只允许单继承  
2.一个父类可以有多个子类,一个子类只有一个直接父类  
3.object是所有类的父类

**super 和 this关键字:**

相同点  
1.指的都是构造函数  
2.只能放在构造函数的第一行

不同点  
super是父类的构造函数,this是自身类的构造函数

## 覆盖 ##

**条件**

*  1.基于继承
 *  2.子类改造父类的方法

**规则**

*  1.方法名一致
 *  2.参数列表一致(参数类型.参数顺序.参数个数都要一致)
 *  3.返回值类型一致

## static关键字(静态关键字) ##

**1.修饰变量(成员变量,全局变量)**  
\-------- 成员静态变量.类变量

属于类级别变量,所有对象共享  
在类加载时,立即创建并保存在内存中,只要类存在,static变量存在

**2.修饰方法(静态方法.类方法)**

访问方式:

类名.方法名  
引用对象.方法名

注意:

静态方法只能直接访问静态成员,而不能直接访问类中的非静态成员  
（因为非静态成员需要在new完成之后才保存在内存中,而静态成员类加载时即保存在内存中）  
静态方法中不能使用this.super关键字（因为this或super表示new出来的引用对象）  
静态方法不能够被非静态方法覆盖  
静态方法不能修饰构造器

**3.修饰代码块 ---------静态代码块**

在类加载时优先执行,并且在整个过程中只执行一次,一般用来初始化

执行顺序:加载类–>静态代码块—>自由代码块—>构造函数

注意:static关键字只能修饰类成员,不能修饰局部变量

## 单例模式 ##

某个类只能有一个实例；  
它必须自行创建这个示例；  
必须自行向整个系统提供这个实例。

代码演示

public class Singleton {
    2. //在自己内部定义自己的一个实例，只供内部调用
    3. private static Singleton instance = new Singleton();
    4. private Singleton(){
    5. //do something
    6. }
    7. //这里提供了一个供外部访问本class的静态方法，可以直接访问
    8. public static Singleton getInstance(){
    9. return instance;
    10. }
    11. }

## 抽象类 ##

抽象方法与非抽象方法的集合

本身不能创建对象,只能通过继承的子类创建对象,可以看做一个模板

抽象就是将相同的但不确定的东西提取出来,为了日后的重用,定义成抽象类的目的,就是为了在子类中实现抽象

**语法:**

<权限修饰符> abstract class 抽象类名{
    		成员变量;
    		非抽象方法;
    		抽象方法;
    }

**抽象类的情况:**  
1.全部是抽象方法  
2.全部是非抽象的(意义不大)

**注意:**  
1.抽象类不能为static. --不允许通过类名.方法名访问抽象方法  
2.抽象类中的抽象方法必须在子类中被实现(覆盖),否则该子类只能声明为abstract  
3.抽象类不能被实例化 --因为抽象类中包含了未实现的抽象方法

**什么情况下,必须使用抽象类:**  
1.当一个类中存在一个或多个抽象方法,必须定义为抽象类  
2.当抽象类的子类,没有对父类所有的抽象方法提供具体的实现,子类只能定义为抽象类

## 接口 ##

常量与抽象方法的集合,定义了一套规则,并没有具体的实现方法

**语法:**