重构Java基础 (四) | 你关心的java面向对象

面向过程

Java是一个面向对象的语言。在一个面向对象的系统中，类（class）是数据和操作数据的方法的集合。数据和方法一起描述对象（object）的状态和行为。每一对象是其状态和行为的封装。类是按一定体系和层次安排的，使得子类可以从超类继承行为。在这个类层次体系中有一个根类，它是具有一般行为的类。Java程序是用类来组织的。

面向对象

OOP（Object Oriented Programming）面向对象编程。面向对象编程实质上就是对现实世界的对象进行建模操作。

类

我们把某些具有相同的属性和行为的事物抽象成一类。
类是模子，确定对象将会拥有的特征（属性）和行为（方法）
类的特点:

• 类是对象的类型
• 具有相同属性和方法的一组对象的集合

猫：
属性：颜色，年龄，体重
行为：睡觉，抓老鼠，吃食

小汽车类：
属性：颜色，马力，四个轮子
行为：行驶，停车

在java语言中万物皆对象（在java里面不是所有的东西都是对象，八种基本数据类型不是对象，jdk1.5以后对于八种基本数据类型都提供了包装类）。

对象

类是一个概念，对象是一个具体的实例。
“有什么”
属性：对象具有的各种静态特征
“能做什么”
方法：对象具有的各种动态行为

类和对象的关系

• 类是抽象的概念，仅仅是模板
• 对象是一个你能够看得到、摸得着的具体实体
• 类是对象的类型
• 对象是特定类型的数据
• 具体开发过程中，先定义类再实例化对象

类的定义

语法:

class 类名{
		属性
		方法
	}

注意:如果是一个类的情况，最好让类名和文件名一致。
类里面只能有属性和行为
类名：要见名之意，要用英文的单词，每一个英文单词的首字符要大写。

属性

在类中定义的变量就是属性，属性可以没有初始值，但是jvm会给属性一个默认值,只有属性才有默认值
基本数据类型的默认值如下表:

基本数据类型	默认值
byte	0
short	0
int	0
long	0
float	0.0
double	0.0
char	‘ ’
boolean	false

引用数据类型的默认值：null

方法

方法：对象具有的各种动态行为
语法:

public <static> 返回值  方法名字（数据类型 变量, 数据类型 变量……）{
	<return>
}

类的实例化

创建类的目的，就是创建对象（类的实例）
语法:

数据类型 变量 = new 数据类型();

实例:

上面实例创建了一个猫类

访问对象的属性:

对象.属性名

调用类的方法:

对象.方法（行为）名

实例:

创建对象的内存的结构

当我们运行类的时候会在内存中产生jvm
Jvm有栈，堆，数据共享区

• 栈：程序运行的时候基本数据类型和引用数据类型的引用所存储的位置,内存小，存取的速度快
• 堆：是对象存储的位置,内存大，存取的速度慢
• 数据共享区：存储共享数据的内存区

数据共享区:

Dog.class
lookHome()
sleep()

//类中的对象方法是被当前类的所有对象共享的。

局部变量

凡是定义在方法内或者是语句块的变量都是局部变量。

如下：

局部变量的特点：

1. 作用范围：只限于所定义的大括号。
2. 存储的位置：存储在栈内存中。
3. 默认值：无，局部变量必须赋值。
4. 生命周期：所属的大括号结束就消失

class Demo1{
	
	public static void main(String[] args){
		//局部的变量只在它的所属的大括号和其子孙括号内有效
		int x = 0;
		if(x > 10){
			System.out.println(x);
		}
	}
	
	public static void add(){
		//定义一个变量
		int i = 0;
		{
			int x = 0;
		}
		//报错的
		System.out.println(x);
		
	}
	//方法的参数这个变量的作用域就是这个方法的体内
	public static void add(int a){
		
	}
	
	public static void multiply(){
		//循环的变量的定义的也是在循环体的大括号内有效
        for(int i=0;i<10;i++){
        
        }
	}	
}

注意：并不是只有基本数据类型才是局部变量

局部变量在使用之前必须要初始化，否则会报错

报错：

局部变量的生命周期

类的封装

面向对象的三大特征：封装、继承、多态
目的：提高数据安全性，通过封装，可以实现对属性的访问权限控制，同时增加了程序的可维护性。

封装性

封装的步骤

1. 属性用private私有
2. 使用set/get赋值,并用this引用
3. 调用方法（方法公有）

实例:

// 对System.out.println();的封装。
public class Test
{
　　public static void test(String str)
　　{
　　System.out.println(str);
　　}
}
　
　　调用
　　public class Use
　　{
　　   public static void main(String[] args)
　　   {
　     Test.test("封装")；
　　   }
　　 }

继承性

若一个类只允许继承一个父类，称为单继承；若允许继承多个父类，则称为多重继承。Java语言通过接口实现了多继承
实例:

Class A{
Public  void  A1(){
		System.out.println(“我是特立独行的鱼儿”);
  }
}
Class B extends A{
	
}

多态性

在这里插入代码片public Class Parents { 
  public void print() {
    System.out.println(“parents”);
  }
}
public Class Father extends Parents { 
  public void print() {
    System.out.println(“father”); 
  }
}
public Class Mother extends Parents {
  public void print() {
    System.out.println(“mother”);
  } 
}
  
public Class Test {
  public void find(Parents p) { 
    p.print();
}
public static void main(String[] args) {
  Test t = new Test();
  Father f = new Father();
  Mother m = new Mother();
  t.find(f);
  t.find(m);
  }
}

This关键字

对象方法中隐藏了一个this关键字, 如果那个对象调用了这个方法那么这个方法里面的this就是这个对象

class Person{
	
	String name;
	int age;
	
	
	public void info(){
	
	/*对象方法中隐藏了一个this关键字, 如果那个对象调用了这个方法那么这个方法里面的this就是这个对象
*/
		System.out.println(this);
		
	}
}

public class TestPerson{
	
	public static void main(String[] args){
		//创建一个Person对象
		Person p = new Person();
		
		System.out.println(p);
		//调用info
		p.info();
			
	}	
}

This在封装中用来区分同名的变量和属性，带有this的是属性
实例：

class Person{
	
	private String name;
	private int age;
	
	public void setName(String name){
		//this.name是属性
		 this.name = name;
	}
	
	public String getName(){
		return name;
	}
	
	public void setAge(int age){
		this.age = age;
	}
	
	public int  getAge(){
		return age;
	}
}

构造器

构造器本身是一个方法：

• 没有返回值，也没有void。
• 构造器的方法名必须和类名一致
• 在方法中定义要初始化的参数列表
  作用：创建对象，给对象赋初始值；

默认构造器

public Person(){
   System.out.println("我是被鱼儿调用的构造器");
}

一个类的构造器没有任何参数这就是默认构造器，如果不写的话也是默认存在的，方法体什么都没有，我们也可以显示的定义出来。

有参数的构造器

实例：

public Person(String name, int age){
		//给属性赋值
		this.name = name;
		this.age = age;
	}

使用有参数的构造器创建对象：

Person p1 = new Person("特立独行的鱼儿", 20);
		p1.info();

如果一个类里面存在着一个有参的构造器的话，那么无参数的默认构造器就会被覆盖，就不能使用，如果想要使用这个默认的构造器就必须把它显示的定义出来。

构造器直接的调用

public Person(String name, int age){
		this.name = name;
		this.age = age;
	}
	
	
	public Person(String name, int age, String gender){
	
		//通过this的用法调用本类的构造器
	
		/*
		this.name = name;
		this.age = age;
		*/
		this(name, age);
		this.gender = gender;
	}

通过this(变量，变量….)这种方式来调用本类的构造器，必须放在调用的第一行。

单例模式

我们以往创建对象的时候，通过一个类是可以创建很多个对象的，但是我们想要让一个类就只能创建一个对象。
懒汉模式
实例：

class Singleton{
	
	private static Singleton s;
	
	//给构造器私有化
	private Singleton(){
		
	}
	
	//私有化构造器之后，肯定不能被外部使用
	
	public static Singleton getInstance(){
		if(s == null){
			s = new Singleton();
		}
		return s;
	}
}


class TestSingleton{
	
	public static void main(String[] args){
		Singleton s = Singleton.getInstance();
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s);
		System.out.println(s1);
		System.out.println(s2);
	}
}