Java之面向对象详解

ゝ一纸荒年。 2023-02-24 03:46 6阅读 0赞

## 面向对象 ##

面向对象是相对面向过程而言  
面向对象和面向过程都是一种思想  
面向过程强调的是功能行为  
面向对象是将功能封装进对象，强调了具备功能的对象  
面向对象是基于面向过程的  
**开发**  
找对象、建立对象、使用对象，指挥对象做事情  
**设计**  
管理和维护对象之间的关系  
**面向对象三大特征**  
封装、继承、多态  
**类和面向对象的关系**  
类就是对现实生活中事物的描述，描述事物的类就是描述事物的属性和行为  
对象就是这类事物实实在在存在的个体  
**成员变量和局部变量的区别**  
1、作用范围不同  
成员变量定义在类中，整个类中都可以访问到  
局部变量定义在函数、语句等局部范围内，只能在局部访问  
2、在内存中的位置不同  
成员变量随着对象的建立而建立，存在于对象所在的堆内存中  
局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放  
3、是否有默认初始化值  
成员变量存在默认初始化值，字符串初始值为null，数字初始值为0  
局部变量不存在默认初始化值

/** *汽车类 *类中包含成员变量和成员方法 */
    class Car { 
    	/** *颜色 */
    	String color = "red";
    	/** *轮胎数 */
    	int num = 4;
    	/** *运行方法 */
    	void run() { 
    		System.out.println(color + "--" + num);
    	}
    }
    class CarDemo{ 
    	public static void main(String[] args){ 
    		/** *创建类实例 */
    		Car c = new Car(); //这是一个类类型对象
    		c.color = "blue"; //修改对象的属性
    		c.run(); //调用对象的方法
    		/* *匿名对象 *两种使用情况 *1、对对象方法只进行一次调用。如果对对象的多个成员进行调用，必须起名字 *2、作为实际参数进行传递 */
    		new Car().run();
    		show(new Car());
    	}
    	public static void show (Car c) { 
    		c.color = "black";
    		c.num = 5;
    		c.run();
    	}
    }

**对象的内存结构**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70]**匿名对象内存结构**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70 1]**构造函数**  
特点：  
1、函数名与类名相同  
2、不用定义返回值类型  
3、不可以写return语句  
作用：  
用于给对象进行初始化，定义当前事物具备的一些特性或行为  
注意：  
1、当一个类中没有定义构造函数时，系统会默认给该类加入一个空参数的构造函数——类名()\{\}  
2、当在类中自定义了构造函数之后，默认的构造函数就没有了。多个构造函数可以以重载的形式存在  
3、构造函数只运行一次，即对象一建立就运行。普通函数可以运行多次，由函数调用运行。

class Person { 
    	private String name;
    	private int age;
    	/* 构造代码块 作用： 定义不同对象共性的初始化内容 对象一建立就运行，而且优先于构造函数执行 和构造函数的区别： 构造代码块是给所有对象进行统一初始化 而构造函数是给对应的对象进行初始化 */
    	{ 
    		cry();
    	}
    	Person(){ 
    		//特性
    		name = "baby";
    		age = 0;
    		System.out.println("A:name="+name+",age="+age);
    		//行为
    		//cry();
    	}
    	Person(String a){ 
    		name = a;
    		System.out.println("A:name="+name+",age="+age);
    		cry();
    	}
    	Person(String a, int b){ 
    		name = a;
    		age = b;
    		System.out.println("A:name="+name+",age="+age);
    		//cry();
    	}
    	public void cry(){ 
    		System.out.println("cry...");
    	}
    }
    class Constructor { 
    	public static void main (String[] args) { 
    		Person p1 = new Person();
    		Person p2 = new Person("晓红");
    		Person p3 = new Person("晓红", 20);
    		p1.cry();
    	}
    }

**this关键字**  
代表所在函数所属对象的引用  
应用：  
当定义类中功能时，该函数内部要用到调用该函数的对象时，用this来表示这个对象  
**this语句**  
用于构造函数之间进行互相调用  
只能定义在构造函数的第一行，因为初始化要先执行  
**static关键字**  
一个修饰符，用于修饰类中的成员变量和成员函数，一般用于公用的，可以共享的成员  
特点：  
1、随着类的加载而加载，随着类的消失而消失，生命周期最长  
2、优先于对象存在  
3、被所有对象所共享  
4、可以直接被类名调用  
使用注意：（静态方法优先于对象存在，所以对象中的内容在静态方法中不能使用）  
1、静态方法只能访问静态成员  
2、静态方法中不能使用this、super关键字  
3、主函数是静态的  
利处：  
节省空间，存在于方法区（独立的一块内存，用于存方法和数据）中，不用在每一个对象所在的堆中存储  
类可以直接调用  
弊处：  
生命周期过长  
访问有局限性，总能访问静态成员  
什么时候使用：  
对象中存在共享数据，数据需要被静态所修饰  
功能内部没有访问到非静态数据时，功能需要被静态所修饰  
**静态代码块**  
static \{ \}  
随着类的加载而执行，只执行一次  
用于给类进行初始化

class StaticCode { 
    	StaticCode(){ 
    		System.out.println("a");
    	}
    	//静态代码块，对类进行初始化，随着类的加载而执行
    	static { 
    		System.out.println("b");
    	}
    	//构造代码块，对对象进行初始化，随着对象的建立而执行
    	{ 
    		System.out.println("c");
    	}
    	StaticCode(int x){ 
    		System.out.println("d");
    	}
    }
    class StaticCodeDemo { 
    	public static void main(String[] args){ 
    		new StaticCode();//b c a
    	}
    }

**类变量和实例变量的区别**  
1、存放位置  
类变量随着类的加载而存在于方法区中，可以被static修饰  
实例变量随着对象的建立而存在于堆内存中  
2、生命周期  
类变量的生命周期最长，随着类的消失而消失  
实例变量随着对象的消失而消失

class Person { 
    	static String country = "CN";//类变量
    	private String name;//实例变量
    	private int age;
    	Person(String name){ 
    		this.name = name;
    	}
    	Person(String name, int age){ 
    		this(name);//this语句，用于构造函数之间的互相调用
    		this.age = age;
    		//静态方法可以被对象调用
    		this.cry();
    	}
    	public static void cry(){ 
    		System.out.println("cry");
    	}
    	//比较自己和别人的年龄
    	public boolean compare(Person p){ 
    		return this.age==p.age;
    	}
    }
    class KeyWord { 
    	public static void main (String[] args) { 
    		Person p = new Person("晓红",20);
    		Person p1 = new Person("逸轩",2);
    		boolean res = p.compare(p1);
    		System.out.println(res);
    		//静态成员可以由类直接调用
    		Person.cry();
    		System.out.println(Person.country);
    	}
    }

**创建一个对象的内部实现步骤**  
Person p = new Person(“晓红”,20);  
1、先将Person类加载到内存中  
2、执行该类中的static代码块，如果有的话，给类进行初始化  
3、在堆内存中开辟空间，分配内存地址  
4、在堆内存中建立对象的特有属性，并进行默认初始化  
5、对属性进行显示初始化  
6、对对象进行构造代码块初始化  
7、对对象进行对应的构造函数初始化  
8、将内存地址赋给栈内存中的p变量

## 封装 ##

隐藏对象的属性和实现细节，仅对外提供公共访问方式  
好处：  
1、将变化隔离  
2、便于使用  
3、提高重用性  
4、提高安全性

class Persion { 
    	//私有变量，只能在当前类访问，外部无法访问。对外提供get、set方法进行访问与设置，提高对数据访问的安全性
    	private int age;
    	public int getAge () { 
    		return age;
    	}
    	public void setAge (int a) { 
    		if(a>0&&a<140){ 
    			age = a;
    			speak();
    		}else{ 
    			System.out.println("非法传入");
    		}
    	}
    	//方法
    	void speak () { 
    		System.out.println("age="+age);
    	}
    }
    class PersionDemo { 
    	public static void main (String[] args) { 
    		Persion p = new Persion();
    		//p.age = 20;
    		p.setAge(20);
    	}
    }

方法（工具）类的封装，调用只需要  
类名.方法名（参数）

/** 操作数组的工具类，内含获取最值、数组排序、数组打印等方法 @author star @version 1.1 */
    public class ArrayTool { 
    	/** 将构造函数私有化，防止外部创建对象 */
    	private ArrayTool(){ };
    	/** 获取数组中的最大值 @param arr 接收一个int类型的数组 @return 会返回数组中的最大值 */
    	public static int getMax(int[] arr){ 
    		int max = 0;
    		for(int x = 0; x < arr.length; x++){ 
    			if(arr[x]>arr[max])
    				max = x;
    		}
    		return arr[max];
    	}
    	/** 获取数组中的最小值 @param arr 接收一个int类型的数组 @return 会返回数组中的最小值 */
    	public static int getMin(int[] arr){ 
    		int min = 0;
    		for(int x = 0; x < arr.length; x++){ 
    			if(arr[x]<arr[min])
    				min = x;
    		}
    		return arr[min];
    	}
    	/** 数组冒泡排序 @param arr 接收一个int类型的数组 */
    	public static void bubbleSort(int[] arr){ 
    		for(int x = 0; x < arr.length - 1; x++){ 
    			for(int y = 0; y < arr.length - x - 1; y++){ //减1的目的是防止最后y越界
    				samp(arr,y,y+1);
    			}
    		}
    	}
    	/** 数组选择排序 @param arr 接收一个int类型的数组 */
    	public static void selectSort(int[] arr){ 
    		for(int x = 0; x < arr.length - 1; x++){ 
    			for(int y = x + 1; y < arr.length; y++){ 
    				samp(arr,x,y);
    			}
    		}
    	}
    	/** 交换数组中两个元素的位置 @param arr 接收一个int类型的数组 @param x 元素的位置 @param y 元素的位置 */
    	private static void samp(int[] arr, int x, int y){ 
    		if(arr[x]>arr[y]){ 
    			int temp = arr[x];
    			arr[x] = arr[y];
    			arr[y] = temp;
    		}
    	}
    	/** 打印数组，输出格式为[元素1,元素2] @param arr 接收一个int类型的数组 */
    	public static void printArr(int[] arr){ 
    		System.out.print("[");
    		for(int x = 0; x < arr.length; x++){ 
    			if(x!=arr.length-1)
    				System.out.print(arr[x]+",");
    			else
    				System.out.println(arr[x]+"]");
    		}
    	}
    }

## 继承（extends） ##

**特点**  
提高了代码的复用性  
让类与类之间产生了关系，提供了多态的前提  
java支持单继承，不支持多继承（一个类只能有一个父类，不能有多个父类）  
java支持多层继承（C继承B，B继承A）  
**super关键字**  
super和this用法相同  
this代表本类应用  
super代表父类引用  
当子父类出现同名成员时，可以用super区分  
子类要调用父类构造函数时，可以使用super语句（功能内第一行使用，子类构造函数中默认调用super()，初始化父类数据）  
**函数重写（覆盖）**  
子类中出现与父类一模一样（返回值、参数类型都相同）的方法，不同于函数重载  
父类中的私有方法不可以被覆盖  
在子类覆盖的方法中，继续使用父类方法可以通过super.函数名获取  
子类方法权限一定要大于等于父类方法权限才能覆盖，public>默认>private  
静态只能覆盖静态  
**final关键字**  
可以修饰类、方法、变量  
修饰的类不可以被继承  
修饰的方法不可以被覆盖  
修饰的变量为常量，只能初始化一次，常量所有字母大写，单词间用\_连接  
内部类只能访问被final修饰的局部变量

class Animal{ 
    	String name;
    	final int EYE_NUM = 2;//动物都是只有两只眼睛
    	Animal(String name){ 
    		//常量只能初始化一次
    		//this.EYE_NUM = 3;
    		this.name = name;
    	}
    	void speak(){ 
    		System.out.println("............");
    	}
    	static void run(){ 
    		System.out.println("1秒1米");
    	}
    }
    class Dog extends Animal{ 
    	Dog(String name){ 
    		super(name);//通过super关键字调用父方法,必须放在第一行
    	}
    	//函数复写
    	void speak(){ 
    		System.out.println("Wang Wang");
    	}
    	//静态只能覆盖静态
    	static void run(){ 
    		System.out.println("1秒5米");
    	}
    }
    class ExtendsDemo{ 
    	public static void main(String[] args){ 
    		Dog d = new Dog("xiaobai");
    		System.out.println(d.name);
    		d.speak();
    		d.run();
    	}
    }

**抽象类（abstract）**  
对个对象都具备相同的功能，但是功能具体内容有所不同，所以在抽取的过程中，只抽取了功能定义，并为抽取功能主体。只有功能声明没有功能主体的方法叫做抽象方法。拥有抽象方法的类叫做抽象类。  
当然，抽象类中也可以不存在抽象方法，抽象类的定义只是为了确保该类不被实例化  
特点：  
抽象类和抽象方法必须用abstract关键字来修饰  
抽象方法只有方法声明，没有方法主体  
抽象类不可以被实例化  
子类必须复写抽象类中的所有抽象方法后才可以建立对象，否则该子类也是抽象类

//抽象类
    abstract class Employee{ 
    	String name;
    	int age;
    	double pay;
    	Employee(String name, int age, double pay){ 
    		this.name = name;
    		this.age = age;
    		this.pay = pay;
    	}
    	//不同岗位工作不同
    	public abstract void work();
    }
    //普通员工
    class Pro extends Employee{ 
    	Pro(String name, int age, double pay){ 
    		super(name,age,pay);
    	}
    	//复写抽象方法
    	public void work(){ 
    		System.out.println("Pro work");
    	}
    }
    //经理岗位
    class Manager extends Employee{ 
    	private double bonus;
    	Manager(String name, int age, double pay, double bonus){ 
    		super(name,age,pay);
    		this.bonus = bonus;
    	}
    	//复写抽象方法
    	public void work(){ 
    		System.out.println("Manager work");
    	}
    }
    class EmployeeDemo{ 
    	public static void main(String[] args){ 
    		Pro pro1 = new Pro("小白", 28, 5000);
    		pro1.work();
    		Manager man1 = new Manager("小虎", 35, 7000, 5000);
    		man1.work();
    	}
    }

**接口(interface)**  
对外暴露规则  
程序扩展功能

接口中的成员修饰符是固定的。

*  成员常量：public static final
 *  成员函数：public abstract

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

接口、类、对象之间的关系：

*  类实现接口，对象为类的实例
 *  接口与接口之间是继承关系，支持多继承
 *  类与类之间是继承关系，不支持多继承
 *  类与接口之间是实现关系，支持多实现
 *  类可以同时继承类且实现接口

interface InterA{ 
    	//接口中，变量需要用public static final修饰，方法需要用public abstract修饰，即接口中只能存在常量和抽象方法
    	public static final int NUM = 3;
    	public abstract void show();	
    }
    interface InterB{ 
    	public abstract void run();
    }
    //接口间可以多继承
    interface InterC extends InterA,InterB{ 
    	public abstract void jump();
    }
    class Person{ 
    	String name;
    	int age;
    	Person(String name,int age){ 
    		this.name = name;
    		this.age = age;
    	}
    }
    //类继承类且实现接口
    class Student extends Person implements InterC{ 
    	//类实现接口需要复写接口中的所有抽象方法才能实例化
    	Student(String name,int age){ 
    		super(name,age);
    	}
    	//接口中抽象方法的权限为public，所以类中也必须是
    	public void show(){ }
    	public void run(){ }
    	public void jump(){ }
    }
    class InterfaceDemo{ 
    	public static void main(String[] args) { 
    		Student s1 = new Student("xiaobai",20);	
    	}
    }

## 多态 ##

定义：某一类事物的多种存在形态  
体现：父类或者接口的引用指向接收自己的子类对象  
作用：提高了程序的扩展性和后期的可维护性  
前提：需要存在继承或者实现关系；要有覆盖操作  
弊端：只能使用父类的引用访问父类中的成员  
代码中的特点：

> 多态中，在编译时期，参阅引用型变量所属的类中变量和方法是否有，如果有则编译通过，否则编译失败

> 多态中，成员函数的特点  
> 在编译时期，参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，没有则编译失败  
> 在运行时期，参阅对象所属的类中是否有调用的方法

> 多态中，成员变量的特点  
> 无论编译和运行，都参考左边（引用型变量所属的类）

> 多态中，静态成员函数的特点  
> 无论编译和运行，都参考左边

类多态

abstract class Animal{ 
    	abstract void eat();
    	void sleep(){ 
    		System.out.println("睡觉");
    	}
    }
    class Dog extends Animal{ 
    	public void eat(){ 
    		System.out.println("吃骨头");
    	}
    	void kanMen(){ 
    		System.out.println("看门");
    	}
    }
    class Cat extends Animal{ 
    	public void eat(){ 
    		System.out.println("吃鱼");
    	}
    	void zhuaShu(){ 
    		System.out.println("抓老鼠");
    	}
    }
    class DuoTaiDemo{ 
    	public static void main(String[] args){ 
    		//父类型引用指向了子类对象，类型提升 
    		Animal d = new Dog();
    		behavior(d);
    		behavior(new Cat());
    	}
    	public static void behavior(Animal a){ 
    		a.eat();
    		//判断一个对象是否是一个类的实例
    		if(a instanceof Dog){ 
    			//类型强转换
    			Dog d = (Dog)a;
    			d.kanMen();
    		}
    		if(a instanceof Cat){ 
    			Cat c = (Cat)a;
    			c.zhuaShu();
    		}
    	}
    }

多态总的成员函数、变量特点

class Fu{ 
    	int num = 5;
    	void show(){ 
    		System.out.println("fu show");
    	}
    	static void run(){ 
    		System.out.println("fu run");
    	}
    }
    class Zi extends Fu{ 
    	int num = 6;
    	void show(){ 
    		System.out.println("zi show");
    	}
    	static void run(){ 
    		System.out.println("zi run");
    	}
    }
    class DuoTaiDemo2{ 
    	public static void main(String[] args){ 
    		Fu f = new Zi();
    		//成员变量都参考左边
    		System.out.println(f.num);//5
    		//成员函数运行时，参阅对象所属类中的方法
    		f.show();//zi show
    		//静态成员函数参考左边
    		f.run();//fu run
    	}
    }

接口多态

interface A{ 
    	public void open();
    	public void close();
    }
    class B{ 
    	//接口引用指向子类对象
    	void run(A a){ 
    		if(a!=null){ 
    			a.open();
    			a.close();
    		}
    	}
    }
    class C implements A{ 
    	public void open(){ 
    		System.out.println("C open");
    	}
    	public void close(){ 
    		System.out.println("C close");
    	}
    }
    class DuoTaiDemo3{ 
    	public static void main(String[] args) { 
    		B b = new B();
    		b.run(new C());
    	}
    }

## 内部类 ##

将一个类定义在另一个类的里面，里面的类就称为内部类（内置类、嵌套类）  
**访问规则**

1.  内部类可以直接访问外部类的成员，包括私有。这是因为内部类中持有了一个外部类的引用，格式为 外部类名.this
2.  外部类要访问内部类，必须要建立内部类对象

**访问格式**

1.  当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中访问，可以直接建立内部类对象。 Outer.Inner in = new Outer().new Inner();
2.  当内部类在成员位置上，可以被成员修饰符所修饰（private、static等）  
    private：将内部类在外部类中进行了封装  
    static：内部类就具备了static的特性，只能直接访问外部类中的静态成员（访问局限）  
    在外部其他类中，直接访问静态内部类的非静态方法：new Outer.Inner().show();  
    在外部其他类中，直接访问静态内部类的静态方法：Outer.Inner.show();  
    当内部类中定义了静态成员，该内部类必须是静态的  
    当外部类中的静态方法访问内部类时，内部类也必须是静态的
3.  当内部类定义在局部位置上，不可以被成员修饰符修饰。  
    可以直接访问外部类成员，因为还有外部类的引用。  
    不可以直接访问它所在局部中的变量，局部变量被final修饰之后可以访问。

**匿名内部类**

*  就是内部类的简化写法。
 *  前提：内部类可以继承或实现一个外部类或者接口。
 *  格式为：new 外部类名或者接口名()\{覆盖类或者接口中的代码\}
 *  简单理解：就是建立一个带内容的外部类或者接口的子类匿名对象

**demo1**

//外部类
    class Outer{ 
    	int x = 3;
    	//内部类
    	class Inner{ 
    		int x = 4;
    		void show(){ 
    			int x = 5;
    			System.out.println("Inner"+x);//5
    			System.out.println("Inner"+this.x);//4
    			//内部类可以直接使用外部类中的成员,因为Outer.this可以直接访问到外部类
    			System.out.println("Inner"+Outer.this.x);//3
    		}
    	}
    	void methods(){ 
    		//外部类使用内部类，必须要定义对象
    		Inner in = new Inner();
    		in.show();
    	}
    }
    class InnerClassDemo{ 
    	public static void main(String[] args){ 
    		Outer ot = new Outer();
    		ot.methods();
    		//外部直接使用内部类，需要指明是哪个类的内部类
    		Outer.Inner in = new Outer().new Inner();
    		in.show();
    	}
    }

**demo2放在成员位置上**

//外部类
    class Outer{ 
    	static int x = 3;
    	//内部类
    	static class Inner{ 
    		static void show(){ 
    			//静态成员只能访问静态变量
    			System.out.println("Inner"+x);
    		}
    	}
    	static void method(){ 
    		Inner.show();
    	}
    }
    class InnerClassDemo2{ 
    	public static void main(String[] args){ 
    		//new Outer.Inner().show();
    		//Outer.Inner.show();
    		Outer.method();
    	}
    }

**demo3放在局部位置上**

//外部类
    class Outer{ 
    	int x = 3;
    	void method(){ 
    		final int y = 5;
    		//内部类放在局部位置上，不能用修饰符修饰
    		class Inner{ 
    			void show(){ 
    				System.out.println(y);
    			}
    		}
    		new Inner().show();
    	}
    }
    class InnerClassDemo3{ 
    	public static void main(String[] args){ 
    		new Outer().method();
    	}
    }

**demo4匿名内部类**

abstract class AbsDemo{ 
    	abstract void show();
    }
    //外部类
    class Outer{ 
    	int x = 3;
    	public static AbsDemo method(){ 
    		//匿名内部类,父类中方法最多三个较为合适
    		return new AbsDemo(){ 
    			void show(){ 
    				System.out.println("show run");
    			}
    		};
    	}
    }
    class InnerClassDemo4{ 
    	public static void main(String[] args){ 
    		Outer.method().show();
    		//Object为所有类的父类
    		new Object(){ 
    			void run(){ 
    				System.out.println("run ...");
    			}
    		}.run();
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70]: /images/20230209/fa1d2f9de0dc4b3eaa968621ee6a86b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk3MDk4Nw_size_16_color_FFFFFF_t_70 1]: /images/20230209/65701aa6a92d44d597650d961074dc78.png