【四】狂神Java笔记-面向对象

面向对象

以类的方式组织代码，以对象的组织（封装）数据。
面向过程是具体的，面向对象是抽象的。
三大特性：

• 封装
• 继承
• 多态

抽象：抽象就是abstract，简化的意思。就是把某个东西简化成几个点。
从认识论角度分析：先有对象后有类。对象，是具体的事物；类，是抽象的，是对 对象的抽象。
从代码运行的角度分析：先有类后有对象。类是对象的模板。

class修饰的就是一个类

/*
修饰符  返回值类型  方法名（参数...）{
	//方法体
	return 返回值;
}
//return返回值的类型要对应，如果为void可谓空，即 return;
*/

//throws抛出一个异常
public void readFile(String file) throws IOException{
}

方法

• 静态方法-static
• 非静态方法-没有static

1.如果加了静态方法
可以直接 类名.方法名()调用
2.如果是非静态方法无法使用以上用法
需要先实例化这个类 ：对象类型 对象名 = new 对象值，再进行 类名.方法名()调用方法

Student student = new Student();//或者new Srudent().say();
student.say();

如果在同一个文件夹中，静态方法可以调用静态方法，静态方法不能调用非静态方法。
static静态和类是一起加载；非静态对象，是类实例化后才存在。

java都是值传递 ，如果方法中没有return返回值，返回为空
引用传递：传递的是对象，本质还是值传递

类就是一种抽象的数据类型，使用时需要实例化，动物、植物、手机…
对象就是抽象概念的具体实例，对象是抽象概念的具体实例，如张三是人的一个具体实例、张三家里的狗旺财就是狗的一个具体实例。
新建的一个类文件，里面不应该有main函数，一个项目只有一个mian方法。
this.属性，其中this指代当前这个类，后面接这个类里面的属性/字段，例String name、int age。

• 使用new来创建对象。 使用new关键字创建的时候，除了分配内存之外，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用。
• 类中的构造器也被称为构造方法，创建对象时必须要调用。有以下特点： 必须和类的名字相同 没有返回类型，也不能写void
• 一个类即使什么都不写，也会存在一个默认的构造方法
  

构造器

一个类即使什么都不写，也会存在一个方法。
类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下特点：

1. 必须和类的名字相同
2. 必须没有返回类型，也不能写void
   作用：
   使用new关键字，必须要有构造器。
   用来初始化值
   注意：
   定义有参构造后，如果想使用无参构造，显示的定义一个无参构造。

类与对象：
类是一个模板：抽象；对象是一个具体的实例。

属性私有：private
//提供一些可以操作这个属性的方法
提供一些public 的get、set方法
get 获得这个数据/属性
set 给这个数据设置值

get和set方法

alt + insert

特点：

1. 提高程序的安全性，
2. 保护数据
3. 隐藏代码的实现细节
4. 统一接口
5. 系统可维护增加了

继承

扩展，子类是父类的扩展
Java只有单继承，没有多继承。一个儿子只有一个爸爸，一个爸爸可以多个儿子。
在JAVA中，所有的类，都默认继承Object类

public class Student extends Person{
}

子类继承父类，就会拥有父类的全部方法。
private 私有的是无法继承的
public
protected
default
private

super

只要你重写了有参构造，先把无参构造加上。

重写

重写都是方法的重写，与属性无关

用B类新建了A类的对象，把A赋值给了B，这时候B是A，A又继承了B类，向上转型。所以调用B类方法的时候，也就是B=>test
j
Override 重写

静态属于类，非静态属于对象

重写是子类重写父类的方法，而且子类必须继承父类；
子类重写了父类的方法，执行子类的方法。

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大。
4. 抛出的异常，可以被缩小，但不能扩大。

区别：重载是对本类的

为什么需要重写：

1. 父类的共呢个，子类不一定需要，或者不一定满足。
2. alt+inter Override

多态

动态编译：

能调哪些方法，是引用决定的，具体要执行哪个类的方法，是引用指向的对象决定的。
就是子类能调用父类的方法和自己的方法，父类只能调用自己的方法。

那个 报错只要进行一个强制转化，((Student) s2).eat();
注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类要有联系 ，不然就会产生类型转换异常 classCastException
3. 哪个类型就是执行谁的，当两个类型的父类和子类中出现相同的方法，要执行子类的方法。
4. 存在的条件：继承关系，方法需要重写，父类引用指向子类对象，Father f1 = new Son();

---

static 方法，属于类，它不属于实例
final 常量
private 私有方法，不能重写

instanceof （类型转化） 引用类型

System.out.println(x instanceof Y);  //能不能编译通过

1.能否编译通过，看类，x与y的类（实际x，y本身就是类）若存在父子或子父关系责可编译
2.若x与y没有子父关系，如teacher与student，就不可编译。
3.编译过后T/F看引用指向对象，x指向的对象如果是后面y的子类，即是T。
4.纠正一个我之前说的不对的，x只是个名字，在这个例子里刚好是类名罢了。
5.再补充一点我自己测试的，你们可以自测，如果x引用指向的对象与y是父子关系，即y继承前者，那么编译后是false。

• 子类转父类，子类拓展的方法就会丢失。
• 父类引用指向子类的对象。
• 把子类转换为父类，向上转型。不需要强制转换。
• 把父类转换为子类，向下转型，强制转换。
• 方便方法的调用，减少重复的代码。

Static

非静态的方法可以调用静态方法。
记住加了static就是从属于这个类，其他人用不了，只有本类能用。
静态随着类的加载就存在了

Static主函数里，可以直接调这个类中的其他static静态方法，例：Student.go();或直接：go();
非静态方法可以直接调用静态方法里的东西。
静态方法不能直接调用普通方法。
Static的代码块是根据类一加载就执行，执行一次。

static{
	//静态代码块
}

抽象类

public abatract class Action{
	//约束，有人帮我们实现
	//abstract,抽象方法，只有方法名字，没有方法的实现
}

抽象类的所有方法，继承了他的子类，都必须要实现他的方法。
这句话有歧义，应该是：抽象类的子类必须实现父类的所有方法

类 extends：单继承；但是接口可以多继承

1. 不能new这个抽象类，只能靠子类去实现它：约束
2. 抽象方法必须在抽象类中，抽象类中可以写普通方法

思考：抽象类存在的意义？

接口

interface 关键字，接口都需要实现类，一般实现类命名都是Impl结尾
抽象类只可以继承一个，但是接口可以继承多个
一般都是定义一些方法

public interface UserService{
	//接口中的所有定义都是抽象的
}

类可以实现接口，implements 接口
如果要实现接口里面的所有定义（类），必要重写接口中的方法。

作用：
1.约束
2.方法
3.接口不能被实例化，接口中没有构造方法。
4.implements可以实现多个接口。
必须要重写接口中的方法。

内部类

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类。而A类相对于B类来说就是外部类。

异常

Java把异常当作对象来处理

异常处理机制
异常处理的五个关键字：try、catch、finally、throw、throws

try{
	//监控区域
	System，out.println(a/b);
}catch(ArrithmeticException e){  //catch 捕获异常，括号里面是 想要捕获的异常类型
	System.out.pringln("程序出现异常，什么原因")
}catch(Error e){  //catch 捕获异常，括号里面是 想要捕获的异常类型
	System.out.pringln("程序出现异常，什么原因")
}catch(Throwable e){  //catch 捕获异常，括号里面是 想要捕获的异常类型
	System.out.pringln("程序出现异常，什么原因")
}finally{
	//处理善后工作，可以不要，比如一些io、资源，在finally里关闭
}

catch括号里面的异常类型，假设要捕获多个异常，要从小到大捕获异常。

选中代码，ctrl+alt+t创建异常处理，如果打开QQ占用该快捷键，使用ctrl+win+alt+t

假设这个方法中，处理不了这个异常，方法上抛出这个异常。
throws和throw的区别是不管程序有没有异常，只要执行到throw语句就一定会抛一个异常。