老罗课堂笔记：
面向对象概念：
1、在java语言中，把所有的一切事物都看作对象 ，一种是可见的，莫得着。一种是虚拟的物体
2、面向过程编程和面向对象编程的区别是什么？
面向过程编程主要是描述一件事或者一个过程的执行
面向对象编程主要是用语言描述将现实世界中存在的事物，或者规律。无限接近机器识别的语言。
3、对象：在java中所有的对象都是Object
对象包含哪些属性和特征？对象的属性，属性是区别于其他事物的特征。
对象的行为特征，所有的对象都有自己的属性和行为，两者加起来是区别于其他事物的标准。
4、在java用什么来描述一个类？
类和对象的关系 Class和Object的关系
类的概念：类是所有对象的抽象概念或者集合(物以类聚)，对象称为类的具体实例。
类是抽象的，对象是具体
5、对象实例化 new 关键字 实例化对象或者创造一个对象
对象和对象引用的关系 电视机和遥控器的关系，拿到了遥控器就可以控制电视机
Person person = new Person();
person 表示对象引用
在new一个对象的过程中，计算机做了什么？
在内存中申请一片独立的空间，表示可以使用独立的空间来运行程序.
6、面向对象的三大特性：
封装：隐藏内部实现的细节，对外提供公共的访问方法(接口)
好处：从代码设计者的角度，一个是安全性，防止代码被修改破坏。从调用者角度，忽略实现细节，只关注功能怎么调用。
如何设计封装：成员变量尽量私有化(private)，对外提供公有的方法
继承:
多态
7、package 包的概念引入：
对所有的class进行分类，以方便管理。包命名的规则：小写字母，一般都是四级目录
com.公司名.项目名.模块名称
如何编译包：
javac -d . 类名.java
javac -d . *.java
如何执行：
java 全路径(包名/../../类名)
cd 到指定的目录去执行java 命令
8、构造方法：什么是构造方法？构造方法是一个类在初始化的形态，类本身自带特征。
jvm在构建一个类的时候，会构建一个默认的构造方法。
javap 全类路径 XX
构造方法的特点：
公有的、和类名相同、没有返回值
构造方法的用处在哪里？
初始化成员变量。
构造方法越多，代表在这个类初始化的时候，形态越多,功能约强大。
构造方法的重载概念(overload)
构造方法的重载，参数类型不同，参数个数不同，参数次序不同 都能构成重载。仅仅限于本类。
9、类的成员方法：
方法的概念：方法是一个类接收外部信息的其中的渠道。
方法在一个类中专门解决业务逻辑的。
public 返回值 方法名(参数列表){
// return 返回值;
}
10、方法参数的传递：传值或者传递引用
方法的参数传递只能传递两种类型：
如果要是传值，就是一个具体的值
如果要传递引用，那么传递的该对象的地址
11、static 用来修饰静态的方法、静态的代码模块、静态变量
如果使用static所修饰的方法或者变量，可以使用类名直接调用，
不需要new对象来调用.
static 修饰的变量在内存中只有唯一的一个地址，
使用场景：只有在工具类中才可以使用，该方法被频繁的调用，确实节省内存空间
12、类的继承 extends
类与类的关系有哪些？
第一种是关联(has-a)关系(聚合)、第二种是继承(is-a)关系
如果是关联关系，那么就是类调用类的关系。
所有的对象都是继承Object类，java是单根继承的特点
单根继承的好处是什么？不好的地方？
子类可以调用父类的方法，减少代码的冗余度。
在父类的角度考虑问题，继承可以延伸父类的功能(扩大功能)
如果子类继承父类，子类可以调用父类的公有方法，不能调用父类的私有方法
子类调用父类的时候，父类的构造方法会被调用
super关键字只能存在子类中，主要在子类的方法中调用父类的方法，包括构造方法，一般写在程序的第一行
super可以在子类的构造方法中调用父类的构造方法super();
重写(override)子类覆盖父类的同名方法，好处在于扩充子类的方法功能。
里氏替换原则，如果B类和C类有相同的属性和方法，就应该把相同的属性和方法提取到A类中，让B类和C类继承A类
13、final关键字
表示最终的。如果用final 所修饰的变量，称为常量(不能被改变或者赋值)。
如果final修饰一个方法，那么该方法在子类中不能被重写。
如果final 修饰一个类，那么这个类不能被继承。
14、抽象类 abstract 关键字
public abstract class 类名{
}
抽象类和普通类的区别是什么？
抽象类是不能被实例化的，也就是不能使用new 关键字，普通类是可以实例化的
如果一个类有抽象方法，那么这个类必然是抽象类，反之抽象类不一定有抽象方法。
定义一个抽象类的用途在哪里？
抽象的概念是不需要实际去做的，但是在实际应用中有两种场景用途：
1、父类某一个功能或者方法，需要子类强行去重写的，那么该方法必须是抽象的，这个类必须是抽象类。
2、父类对于某一个方法，无法预知子类会怎么实现，那么该方法必须是抽象的。
抽象类在继承的关系图中起到什么作用？
承上启下的作用
15、接口 interface
接口的概念：
接口是一种标准，所有实现该接口的子类都要实现这个标准。
接口也是一种契约，所有实现该接口的子类都要实现该契约的条款
接口也是一种身份特征，所有的子类都具有该身份特征。
接口里面的所有方法都是抽象的、公有的
接口里所有的成员变量都是常量
接口可以继承吗？接口是可以继承接口的。
16、多态
什么是多态？一个事物在不同的条件下，所表现的多种形态。
在开发中使用多态的场景，主要是使用在方法的参数传递上，可以传递接口、也可以传递抽象类
17、异常 Exception
异常是一个对象
异常就是错误，是在程序编译阶段或者执行过程中的错误。
学习异常主要是调试程序的错误信息，根据错误信息来发现程序的bug
异常的分类：运行时态异常和编译时异常
异常的级别：Error和Exception
Error：表示不可抗阻因素造成的。
Exception：表示程序运行错误，是可以调试的。
捕获异常的语法
try{
//假设代码运行正常......
}catch(异常类型){
//程序出错了，要做什么，比如打印输出错误信息
}finally{
//不管程序是否出错，都执行
}
异常的类型必须是明确的，这样才能准确的找出错误。
throws 和 throw 的区别 声明异常和 抛出异常
自定义异常信息：标准的异常中无法描述错误信息，我们需要自己定义一个异常信息。
什么时候捕获异常？什么时候抛出异常？
如果我们调用的是标准的API文档的方法，如果该类或者方法抛出异常，我们必须要捕获
在实际开发中，我们所编写的程序的功能执行成功与否，与外界有紧密关系(比如，参数传递、调用关系)
必须要抛出异常。
吴波老师笔记：
继承：
1 减少重复代码
2 在已有的类上进行功能的扩充
继承的限制：
1：只能存在单继承 （不能多重继承） 例如 class A extends b,c {} × 可以多层继承 b extends a
C extends b
2 构造方法 ： 子类是实例化的时候 首先先执行父类的构造方法 为什么？ 继承父类的属性
3 方法上： 方法的覆写 方法名称 参数类型 返回值类型 和父类的方法完全一致 子类的访问修饰符 不能比父类更严格
例如： void fun(); 子类 public void fun();
方法的重载 和方法的覆写 由什么区别？
方法的重载： 方法名称相同 参数的类型与个数不同 与返回值无关
多态：
对象的多态：向上转型 和向下转型
方法的多态： 方法的重载 方法的覆写
对象的多态：
对象的多态 一定是在继承关系中，实现了方法的覆写：
在开发中 向上转型使用 90%
不转型 5 %
向下转型5 %
对于向下转型是存在危险系数的，在多态上存在限制：
1 在向下转型之前，必须向上转型 两个类必须存在关系 才能向下转型
可以通过 关键字 instanceof 来判断两个类是否存在关系, 该关键字的语法格式如下：
对象 instacneof 类 boolean true false
范例：对象的向上和向下转型
| public static void main(String[] args) { //向上转型 A a=new B(); //A类 实例化 子类对象 调用的方法 依然是子类的对象 new 子类 父类的方法被子类覆写 调用的一定是子类的方法
if(a instanceof B) {
B b=(B)a; //向下转型 b.fly(); } |
需求：
定义一个方法 可以接收 A类 的任意子类对象 30000个子类
Public void fun(B b);
Public void fun (C c)
多态：
对象的向上和向下转型：
向上转型:统一标准 A 父类 c d e f子类 都可以按照父类的标准 执行
向下转型的意义： 使用子类独有的方法
输出字节 父类 输出
输出 输出 输出
A File输出的内容变为文件 B 输出内容到内存 C 对象
向下转型： 实现自己独有的方法
静态只能访问静态，静态成员和方法都是属于类的。
1.需求：贵妇从宠物店购买了宠物狗、宠物猫，某天，家里举行聚会，向朋友介绍起自家豢养的宠物的情形。
分析：
类：
贵妇类：
特征：名字
行为：购买宠物狗
购买宠物猫
举行聚会
介绍宠物狗
介绍宠物猫
main:1, xxxx
宠物狗类：
特征：名字
性别
年龄
品种
行为：看家
吃骨头
宠物猫类：
特征：名字
性别
年龄
品种
行为：抓老鼠
吃鱼
题目就不看了，特别简单的初级，主要是这个程序中有对象做参数的用法，记录一下。
可用继承减少代码累赘，以下是没有优化的。
package com.judy.demo;
public class HelloWorld {
public static void main(String[] args) {
Ladys ladys = new Ladys("judy");
ladys.buyCat();
ladys.buyDog();
ladys.party();
Cat cat = new Cat("jerry", 'g', 2, "bule cat");
Dog dog = new Dog("tom", 'b', 1, "jingmao");
ladys.introduceCat(cat);
ladys.introduceDog(dog);
}
}
class Ladys {
private String name;
Ladys(String name) {
this.name = name;
}
public void buyDog() {
System.out.println(name + ",buy buddy dog");
}
public void buyCat() {
System.out.println(name + ",buy buddy cat");
}
public void party() {
System.out.println("holding party");
}
public void introduceDog(Dog dog) {
System.out.print("introducing dog:" + dog.name + ",he like" + " ");
dog.eatBone();
}
public void introduceCat(Cat cat) {
System.out.print("introducing cat:this is," + cat.name + "," + cat.kind + ",she like" + " ");
cat.eatFish();
}
}
class Dog {
protected String name;
protected char sex;
protected int age;
protected String kind;
Dog(String name, char sex, int age, String kind) {
this.name = name;
this.sex = sex;
this.age = age;
this.kind = kind;
}
public void look() {
System.out.println("look at home");
}
public void eatBone() {
System.out.println("eating bone");
}
}
class Cat {
protected String name;
protected char sex;
protected int age;
protected String kind;
Cat(String name, char sex, int age, String kind) {
this.name = name;
this.sex = sex;
this.age = age;
this.kind = kind;
}
public void zhua() {
System.out.println("zhua mouse");
}
public void eatFish() {
System.out.println("eating fish");
}
}