5、面向对象

目录

• 面向对象
  • 1.类与对象
    • 面向对象跟面向过程
    • 分析：
    • 定义类（类的组成）
    • 创建类
    • 调用类的属性和方法
    • 局部变量和全局变量
    • 内存
    • 形参和实参
    • 类和类之间的联系
    • 练习
    • 源代码
    • static
      • static 单例设计模式
    • this
    • 构造方法

面向对象

1.类与对象

面向对象跟面向过程

区别：

​ 面向对象：事物比较复杂，使用简单的线性思维解决不了

​ 面向过程：事物比较简单，使用线性思维可以解决

共同点：面向对象跟面向过程都是解决实际问题的一种思维方式

​ 二者相辅相成，并不是对立，解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间复杂的 关系、方便我们分析整个系统；具体到微观操作，仍然使用面向过程方式来处理

对象：是具体的事物 小明，小红

类：是对对象的抽象 Person

分析：

​ 由多个具体的人（小红，小张，老王）抽象出的特征

​ 静态特征：年龄，姓名，职业

​ 动态特征：吃饭，睡觉，上班

总结：

​ 1.从多个具体事物抽出出来的特征，将这些特征组合起来就是一类事物

​ 2.静态的描述声明为类的成员变量，成员变量描述着有什么

​ 3.动态的描述声明为类的成员方法，成员方法描述着能做什么

​ 4.成员方法可以直接使用成员变量

定义类（类的组成）

属性 field 作用范围：整个类体

方法 method

构造方法 construtor

其他：代码块，静态代码块，内部类

创建类

---类名 对象名 = new 类名();

---Person p = new Person();

调用类的属性和方法

对象名.属性

对象名.方法

public class Person{
	String name;//成员变量
	int age;
	String sex;
	//成员方法
	public void sleep(){
		sout("睡觉");
	}
}

局部变量和全局变量

局部变量：定义在方法里面的，作用范围：只在方法内有效，出来方法就无法使用

全局变量：定义在方法上面，类的下面。作用范围：当前类有效

注意：当全局变量与局部变量重名时，优先使用的是方法的局部变量

内存

栈：
存放：基本数据类型局部变量
先进后出，自下而上存储
方法执行完毕，自动释放空间
堆：
存放new出来的对象
需要垃圾回收器来回收（gc）
方法区：
存放：类的信息(代码)、 static变量、字符串常量等.

形参和实参

定义方法时的参数是形参，调用方法时传递的时实参，调用方法时，要求参数个数相同，类型兼容

参数的传递：基本数据类型传的时传的是值，引用数据类型传的是引用副本

类和类之间的联系

​ 通过创建对象来建立联系，通过调用方法来传递信息

public class Test{
	main(){
		Perosn person = new Person();
		person.name  = "旺财";//成员变量
		person.sleep();//调用方法
	}
}

练习

源代码

//电影类
package liaoxi;
 
public class Movie {
	int id;
	String movieTitle;//电影名
	String director;//导演
	String protagonist;//主演
	int time;
	public Movie() {}
	public Movie(String movieTitle, String director,String protagonist,int time) {
		this.movieTitle = movieTitle;
		this.director = director;
		this.protagonist = protagonist;
		this.time = time;
	}
}
 

//电影管理类
package liaoxi;
 
import java.util.Scanner;
 
public class MovieMannger {
//	Movie movie;
//	Movie[] arr;
	Movie[] arr = new Movie[10];
	Scanner scanner = new Scanner(System.in);
	//主菜单
	public void showMainMenu() {
		System.out.println("欢迎光品横店影视城");
		System.out.println("---------------");
		System.out.println("1.添加电影");
		System.out.println("2.查看电影");
		System.out.println("3.删除电影");
		System.out.println("4.退出");
		System.out.println("---------------");
		System.out.println("请选择");
		int num = scanner.nextInt();
		switch (num) {
		case 1:
			addMovie();
			 returnMenu();
			break;
		case 2:
			showMovie();
			 returnMenu();
			break;
		case 3:
			delMovie();
			 returnMenu();
			break;	
		case 4:
			System.out.println("欢迎下次使用");
			break ;
 
		default:
			System.out.println("你输入的数字有误！请重新输入");
			 showMainMenu();
			break;
		}
	}
	//返回主菜单
	public void returnMenu() {
		System.out.println("输入成功，按0，返回主菜单");
		int num = scanner.nextInt();
		switch (num) {
		case 0:
			showMainMenu();
			break; 
		default:
			 returnMenu();
			break;
		}
	}
	//添加电影
	public void addMovie() {
			Movie movie = new Movie();
			System.out.println("请输入电影名：");
			movie.movieTitle  = scanner.next();
			System.out.println("请输入导演：");
			movie.director = scanner.next();
			System.out.println("请输入主演：");
			movie.protagonist = scanner.next();
			System.out.println("请输入电影时长：");
			movie.time = scanner.nextInt();
			for (int i = 0; i < arr.length; i++) {
				if(arr[i]!=null) {
					continue;
				}else {
					arr[i] = movie;
					break;
				}	
			}
	}
	//查询电影
	public void showMovie() {
		System.out.println("查询电影");
		//System.out.println(arr[0]);
		System.out.println("电影名\t导演\t主演\t时长");
		for (Movie movie : arr) {
			if(movie!=null) {
				System.out.println(movie.movieTitle+"\t"+
						movie.director+"\t"+movie.protagonist+"\t"+movie.time);
			}else {
				break;
			}	
		}
	}
	//删除电影
	public void delMovie() {
		System.out.println("请输入你要删除的电影名：");
		String mvName = scanner.next();
		int index = -1;
		for (int i = 0; i < arr.length; i++) {
			if(arr[i].movieTitle.equals(mvName)){
				index = i;
				break;
			}
		}	
		if(index>=0) {
			for (int i = index; i <arr.length-1; i++) {
				if(arr[i]==null) {
					break;
				}else {
					arr[i] = arr[i+1];
				}
			}
			arr[arr.length-1]=null;
			System.out.println("删除成功！");
		}else {
			System.out.println("你要删除电影不存在");
		}
		
	}
}
 

//测试类
package liaoxi;
 
 
public class MovieSystem {
	public static void main(String[] args) {
		MovieMannger movieMannger = new MovieMannger();
//		movieMannger.movie = movie;			
		//System.out.println(arr[0]);
		movieMannger.showMainMenu();
	}
}
 

static

static是一个关键字，意思是静态的意思，是一个修饰符

1.可以修饰属性【成员变量】，修饰的属性叫静态变量，也叫类静态变量

2.可以修饰方法，叫静态方法，也叫类方法

3.代码块 静态代码块

4.类 静态内部类

package staticdemo02;
/**
 * static:
 * 作用一：
 * 		修饰成员变量，该成员变量称为静态成员变量，
 * 		被修饰的成员变量属于类所有，所有当其他对象被创建出来也会有该变量.
 * 		被赋值一次，所有对象都享有。(放在共享区)
 * 作用二：
 * 		修饰成员方法，该方法称为静态方法，通过类名直接调用，
 * 		可以使用静态成员变量，不能使用非静态的成员变量,
 * 		该类需要完成某种功能时就定义
 * 作用三：
 * 		代码块是类完成调用时，用来初始化的，
 * 		普通代码块：每次创建对象就会调用一次
 * 		静态代码块：用来完成该类对数据的加载，只会调用一次
 * @author lgx
 *
 */
public class Dog {
	String nameString;
	int age;
	static String city;
	//普通的代码块
	{
		System.out.println("普通代码块");
	}
	//静态代码块
	static {
		System.out.println("静态代码块");
	}
	public void test01() {
		System.out.println("haha");
	}
	public static void test02() {
		System.out.println("静态方法");
	}
}

static 单例设计模式

单例设计模式：每次创建对象用的都是同一对象，所有不能使用new关键字来创建对象，需要调用方法来创建（私有化构造方法）

package sigel;
 
import java.util.Scanner;
 
public class UserInfo {
	String username;
	String psw;
	static UserInfo info = null;//给该类对象赋值
	//此方法是用来创建对象的，所以返回值是该类对象
	public static UserInfo creaUserInfo() {
		if(info==null) {//先判断该对象是否存在，如果存在，就不用创建，直接使用就行了
		//所以每次用的都是同一对象
			info = new UserInfo();
			Scanner scanner = new Scanner(System.in);
			System.out.println("请输入注册的用户名：");
			info.username = scanner.next();
			System.out.println("请输入注册的密码：");
			info.psw = scanner.next();
		}
		return info;//返回该类对象
	}
}
 

使用单例对象的好处：

​ 第一、控制资源的使用，通过线程同步来控制资源的并发访问；

​ 第二、控制实例产生的数量，达到节约资源的目的。

​ 第三、作为通信媒介使用，也就是数据共享，它可以在不建立直接关联的条件下，让多个不相关的两 个线程或者进程之间实现通信

​ 比如，数据库连接池的设计一般采用单例模式，数据库连接是一种数据库资源。

实际上，配置信息类、管理类、控制类、门面类、代理类通常被设计为单例类。像Java的Struts、Spring框 架，.Net的Spring.Net框架，以及Php的Zend框架都大量使用了单例模式。

this

1.谁调用成员方法，则表示当前对象的引用

2.可以区分出成员变量跟方法内参数重名问题

public class Dog{
	String name ;
	int age;
	public void test(String name, int age){
		this.name = name;
		this.age = age;
	}
}

3.可以使用this在成员方法中调用其他的成员方法，一般省略

public class Dog{
	String name ;
	int age;
	public void test(String name, int age){
		this.name = name;
		this.age = age;
		//调用其他方法
		//this.test02();一般省略this
		test02();
	}
	public void test02(){
		sout("test02");
	}
}

4.可以在构造方法里面使用this来调用其他的构造方法（使用this调用构造方法时，需要方法第一行），也可以调用类里面的所有方法

构造方法

构造器：类通过构造器创建对象

构造方法：

默认有无参构造器

​ 1.命名：与类名保持一致

​ 2.无需写返回值

​ 3.方便创建对象时初始化操作

​ 4.构造方法可以重载

public class Dog{
	String name ;
	int age;
	public Dog(){}//无参构造方法
	public Dog(String name, int age){
		this.name = name;
		this.age = age;
	}
	public Dog(String name, int age){
		this(name);//会根据参数的个数自动调用对应的构造方法，必须放在第一行
		this.age = age;
	}
	public Dog(String name){
		this.name = name;
	}
	
	public void test(String name, int age){
		this.name = name;
		this.age = age;
	}
}