JAVA面向对象程序设计--老男孩IT

面向对象概述

1. 类与对象
2. 构造方法
3. 访问权限
4. 继承
5. 多态（最重要）
6. 抽象和接口
7. 内存分析

面向对象和面向过程

面向过程：侧重的是过程。
优点：简单
缺点：代码量大了之后，维护性非常差。
面向对象：侧重的是对象。
优点：可扩展性非常强，维护成本非常低。
缺点：新手上手难。

类：
属性：这一类事物拥有的共同属性
动作：这一类事物能共同执行的功能
对象：
对象能干什么？完全取决于类是如何决定的。

写代码
类要使用class来定义。
属性：成员变量来描述，直接写在类中的变量。
动作：成员方法
类 引用 = new 类();

public class Car{
	//成员变量
	String color;
	int speed;
	int seat;

	//成员变量
	public void run(){
		System.out.println("车能跑");
	}

	public static void main(String[] args){
	//int a =10; 写在方法里的变量，局部变量

	//创建对象
	//int a = 10;
	//String color = "red"

	//在面向对象的世界里，变量是没有市场的，这种变量被称为引用。
	//java分为两种数据类型：1.基本数据类型 2.引用数据类型：String和我们创建的所有类
	Car c = new Car();//创建一个名为c的对象 创建了一辆车，如果
	//让车跑

写一个student类

package test; //放在test这个包中

//创建一个类，类名叫作Student
public class Student{

//给一些成员变量，姓名name，分数score，性别sex。
	String name;
	int score;
	String sex;

//定义一些方法，行为
//打招呼
	public void introduce(){
		System.out.println("你好！");
	}

//晒成绩
	public void showscore(){
	if (this.score>80){
			System.out.println("我这次考得不赖，考了"+this.score+"分！");
			System.out.println("能给我奖励吗？\n");
		}else{
			System.out.println("我这次考得太差了，只有"+this.score+"分…");
			System.out.println("对不起，我下次会更努力的。\n");
		}
	}
	
	public static void main(String[]) args {
	Student a = new Student("小明"，90，"男");
	Student b = new Student("小红", 88,"女");
	}

	a.introduce();
	a.showscore();
}

如何识别变量

用面向对象的思维去模拟时钟。

一只钟可以划分为两个两位的显示器。

package clock;

public class Display{
	//定义成员变量，设置显示器显示数字：value,设置显示器数字上限：limit
	private int value = 0;
	private int limit = 0;
	
	//定义构造函数Display
	public Display(int limit) {
		this.limit = limit;
	}

	//定义increase方法，使value递增，如果value到达上限，又重新清零计数。
	public void increase(){
		value++
		if( value == limit){
			value = 0;
		}
	}

	//定义geetValue方法，获取value值
	public int getValue(){
		return value;
	}

	public static void main(String[] args){
		//构造小时显示器
		Display d = new Display(24);
		//死循环，让value+1，打印
		for (;;){
			d.increase()
			System.out.println(d.getValue());
		}
	}
}

时钟的两个显示器：小时显示器和分钟显示器都属于Display类。这两个对象各自独立，没有直接联系。因此他们之间的联系必须通过一个第三方。

public class Clock{
	\\定义成员变量
	private Display minute = new Display(60);
	private Display hour = new Display(24);

	public void start(){
		while (true) {
			minute.increase();
			if ( minute.getValue() == 0 ){
				hour.increase();
			}
			System.out.printf("%02d:%02d\n",hour.getValue(), minute.getValue());
		}
	}

	public static void main(String[] args) {
	Clock clock = new Clock();
	clock.start();
	}
	
}

对象 = 属性 +服务
数据：属性或状态
操作：函数

把数据和对数据的操作放在一起 ——> 封装

编译单元
一个java文件，是一个编译单元。

static 静态

静态的内容在内存中是保留一份的，并且各个对象之间进行共享
使用对象名.静态变量虽然也可以使用静态变量，但容易产生误解。因此更推荐使用类名去访问静态的内容。

特点：

1. 数据共享
2. 属于类的，而不属于对象的
3. 优先于对象产生

通用构造器，静态构造器
创建对象的过程（简单）：

1. 静态构造器
2. 通用构造器
3. 构造方法—>创建对象

由于创建对象的过程是在静态内容加载完成之后，在静态方法和静态块里不能使用this。

静态的内容使用类名去访问。

包和导包

包名通常用公司域名的翻转。
tieba.baidu.com --> com.baidu.tieba
实际上是创建了3层文件夹

以创建com.xyq.entity的包为例

package com.xyq.entity; //包的声明，表示当前类，从属于entity这个包下的

public class Person {
}

再创建一个com.xyq.dao，发现在/com/xyq/的路径下又多了一个dao的包。

package com.xyq.dao;

//把entity包下的Person类导入当前文件夹
import com.xyq.entity.*;
//*把entity下的所有文件都导入

包的本质其实是文件夹
在代码中需要写package包名；
导包：
import 包+类

不需要导包：
1. 在自己包里
2. java.lang包下的所有内容都不需要导包
- String
- System.out.println()

访问权限

1. public 公共的，所有人都可以访问
2. default 包访问权限，在自己包内可以随意访问
3. private 私有的，只能在class里访问的

getter和setter

成员变量一般使用private

继承

集成：子类可以自动拥有父类除了私有内容外的其他所有内容
当出现x是一种y的时候，x就可以继承y
黑熊怪是一种妖怪。

public class 类 extends 父类{
}

作用：简化代码的开发

子类对父类进行了扩展

Super

super：表示父类的内容
This：表示自己类的内容

用super和this来区分父类和子类中重名的内容。

创建对象的过程：先创建父类的对象，然后创建子类对象。

super可以获取到父类的内容
可以调用父类中的构造方法：必须写在

方法的重写

重写：子类对父类中提供的方法进行重新定义
语法：子类和父类中的方法的申明完全一致。

在子类的重写中也调用父类的方法，也叫做方法的半盖。

//子类中的方法必须和父类中的方法完全一致
public void makeCountry(){
	super.makeCountry(); //父类方法的调用
	System.out.println("李世民也想建立一个自己的国家");
}

多态

同一个对象拥有多种形态。
作用：把不同的数据类型进行统一

小知识点：

1. 把子类的对象赋值给父类的变量->向上转型。

2. 把父类的变量转换回子类的变量->向下转型
   向下转型有可能有风险，java要求必须谢强制类型转换（转换之后的数据类型变量）

Final关键字

1. 被final修饰的变量不可以被改变，又被称为常量，又被称为常量。
2. 被final修饰的方法不可以被重写。
3. 被final修饰的类不可以被继承。

final就是不可变

抽象

抽象方法：使用abstract来修饰，不可以有方法体，直接用分号结束即可
抽象类：如果一个类中有抽象方法，这个类必须是一个抽象类

特点：

1. 抽象类不可以创建对象
2. 抽象类的子类：必须重写父类中的抽象方法，否则子类必须也是抽象类
   通过抽象类可以强制地要求子类中必须有哪些方法。

小知识点：抽象类中可以有正常的方法。

接口

接口实际上是一种特殊的抽象方法

/**
* 能继承接口的只能是接口
* 接口和类只能是实现关系 implements
*/
public interface Valuable{//接口使用interface来声明，已经不是类了

//接口中带有的方法都是抽象方法，可以省略掉abstract
//接口中所有的内容都是公开的，公共的

void getMoney(); //接口中所有的方法都是抽象方法，不可以有正常的方法

}

equals 与 ==

• 子类中的equals方法其本质和==是一样的。都是判断内存地址是否一致。
• ==是判断数值是否相等。
• 可以重写默认的equals方法。
• string中的equals方法是判断值是否相等。

toString

• 直接打印类，调用的是toString方法
• 默认的toString方法显示的是该类的：包名+类名+@内存地址
• 可以重写toString方法

instanceof

• 判断这个对象是什么类型的

参数传递问题

• 值传递：把变量的值作为参数进行传递（java里面就是值传递）
• 引用传递：直接把变量变为参数传递（c语言就是引用传递）

面向对象总结

本章重点：

1. 类与对象->封装
2. 构造 this当前类的对象/super父类
3. 访问权限
   public/private
4. 继承
5. 多态：让java更为灵活
6. 抽象 abstract 对子类进行约束
7. 接口 特殊的抽象类
8. 内存简单分析

异常

• 异常是错误，有编译时异常，运行时异常。

运行时异常

• 抛异常，创建一个错误对象，把错误对象丢出来
• 捕获异常，默认有JVM来把错误信息运行捕获，程序会中断，打印出来。

分类

• RuntimeException：运行时异常，一般不手动处理，出问题再处理
• 其他Exception：必须要经过手动处理
• Error：一般的是系统及错误

处理异常

• try-catch

 try {
>   尝试执行的代码
> }catch{Exception e}{
>   处理异常的代码
> } finally{
> //收尾工作
> }> 

• throw

throws表示方法准备要扔出来一个异常
产生的错误尽可能地自己处理，少向外抛出异常
throw 表示向外抛出异常

自定义异常

略