Day01 面向对象 继承 抽象类 接口 static
1.匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。
2.类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。
父类抽取出了共性的内容，子类可以在父类基础上扩展新的属性与方法。
子类拥有父类的所有属性与方法，无需重新定义。并且可以直接使用非私有的父类成员。
1.1 -子类中访问父类成员方法特点
l 子父类中成员方法的特点
当在程序中通过对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法
_面向对象_构造方法
1).任何的类中都有构造方法，如果我们不定义，系统会自动添加一个
默认（公有、无参、什么都不做的）构造方法。
class Student{
public Student(){
}
}
2).每次"创建对象"时，都会自动执行"构造方法"。
3).构造方法的作用：初始化成员属性；
4).构造方法的定义格式：
访问修饰符 构造方法名(同类名)(形参){
}
Super关键字:::当子父类中出现了同名成员变量时，在子类中若要访问父类中的成员变量，必须使用关键字super来完成。
一般的访问不需要使用this关键字，但有些情况必须使用：
1).在某个方法内，局部变量覆盖了成员变量，此时要访问别覆盖的成员变量，
必须使用：this.成员变量名
class Student{
String name;
public void setName(String name){
this.name = name;
}
}
_面向对象_this关键字
1).this是每个类中都有的一个成员变量，由编译器自动添加的；
2).每当创建一个对象时，JVM会自动将这个对象的"引用"赋值给这个this变量；
3).它表示：引用当前对象的.....(成员属性、成员方法等)；
也就是，通过this可以访问"当前对象"的"成员"；
class Student{
private String name;
public void setName(String name){
this.name = name;
}
public void getName(){
return this.name;//表示：当前对象的，name成员属性
}
}
6.1.charAt(int index):获取这个字符串中某个索引位置上的字符
5.boolean endsWith(String str):判断当前字符串是否以str结尾；
6.int indexOf(String str):查找str在当前字符串中的位置。如果没找到，返回-1
注意：以上对字符串操作的所有方法，都不能改变原字符串，都是生成一个新的字符串；
- 在每次创建子类对象时，父类的class文件也会进入内存中。目的在于子类对象中包含了其对应的父类存储空间，便可以包含其父类对象的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。
代码体现在子类的构造方法调用时，一定先调用父类的构造方法。
1.2 8.抽象类&抽象方法的使用
抽象类无法直接创建对象，只能被子类继承后，创建子类对象。
子类需要继承抽象父类并完成最终的方法实现细节(即重写方法，完成方法体)。而此时，方法重写不再是加强父类方法功能，而是父类没有具体实现，子类完成了具体实现，我们将这种方法重写也叫做实现方法。
1.3 抽象类常见疑惑
l 抽象类一定是个父类，因为抽象类时不断抽取共性需求而来的。
l 抽象类中是可以不定义抽象方法的，此时仅仅是不让该类创建对象，用于某些特殊的设计需要。
l 设计时由具体类抽取出抽象类，而开发阶段应该先定义抽象父类，再根据不同需求由父类定义子类。
l }
l 03.面向对象_继承_this和super关键字
l 1).this:
l 1).任何类中都有一个this成员变量；
l 2).当创建对象时，由JVM为其赋值，赋值为当前对象的引用；
l 3).通过this可以访问本类的成员属性、成员方法、构造方法；
l 2).super:
l 1).任何类中都有一个super成员变量；
l 2).当创建对象时，由JVM为其赋值，赋值为父类对象的引用；
l 3).通过super，可以访问父类中的成员变量、成员方法、构造方法；
1.1 this与super
1.1.1 子类对象产生
在每次创建子类对象时，父类的class文件也会进入内存中。目的在于子类对象中包含了其对应的父类存储空间，便可以包含其父类对象的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。
8.面向对象_继承_子类覆盖父类的成员方法（方法重写）
1).有时候，子类需要保留父类的功能(方法名)，但需要做不同的事情。
这时，子类就可以定义一个跟父类那个方法"一模一样"的方法，用来覆盖父类中的原方法。
这种形式就叫：方法的重写
2).重写规则：
1).子类方法的"访问修饰符"必须跟父类相同，或者比父类更宽；
从宽到窄：public,protected,(默认)
2).子类方法的：返回值类型，方法名，形参列表必须与父类方法完全相同
3).可以使用@Override强制重写验证；Eclipse会按照重写的语法规则检查你的方法。
3).重写的注意事项：
1).父类的"私有方法"由于不能被继承，所以谈不上被重写；
2).静态方法不能被重写；
4).重写的作用：
保留了父类的功能(相同的方法名)，而且实现了子类特有的行为(子类方法内特有的行为)。
1.
接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。
1.4 2.接口中成员的特点
1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解static与final关键字
2、接口中可以定义方法，方法也有固定的修饰符，public abstract
3、接口不可以创建对象。
4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。
5.由于犬分为很多种类，他们吼叫和吃饭的方式不一样，在描述的时候不能具体化，也就是吼叫和吃饭的行为不能明确。当描述行为时，行为的具体动作不能明确，这时，可以将这个行为写为抽象行为，那么这个类也就是抽象类。
可是当缉毒犬有其他额外功能时，而这个功能并不在这个事物的体系中。这时可以让缉毒犬具备犬科自身特点的同时也有其他额外功能，可以将这个额外功能定义接口中。
6.相同点:
l 都位于继承的顶端,用于被其他类实现或继承;
l 都不能直接实例化对象;
l 都包含抽象方法,其子类都必须覆写这些抽象方法;
区别:
l 抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;接口只能包含抽象方法;
l 一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)
l 抽象类为继承体系中的共性内容,接口为继承体系中的扩展功能
1.1 抽象类&抽象方法的使用
抽象类无法直接创建对象，只能被子类继承后，创建子类对象。
子类需要继承抽象父类并完成最终的方法实现细节(即重写方法，完成方法体)。而此时，方法重写不再是加强父类方法功能，而是父类没有具体实现，子类完成了具体实现，我们将这种方法重写也叫做实现方法。
抽象类是拥有构造方法的，其存在的意义在于对自身进行初始化，供其子类使用。
二者的选用:
l 优先选用接口,尽量少用抽象类;
l 需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;
3.父类引用指向子类对象就是多态的定义格式。同一个父类的方法会被不同的子类重写为各自的具体实现。在调用方法时，调用的为各个子类重写后的方法。
父类类型 变量名 = new 子类类型();
变量名.方法名();
此时，虽然该变量指向的是子类对象，但表现为一个父类的形态，可以调用一切父类的方法，子类特有的方法将不能调用。
1.5 多态调用注意事项
l 成员变量编译看父类中是否存在,不存在编译失败
l 成员变量运行父类中的变量
l 成员方法编译看父类中是否存在,不存在编译失败
l 成员方法运行子类重写的方法
多态的弊端: 不能调用子类的特有方法
.面向对象_多态_多态中成员的访问_总结
1.多态时，访问的任何成员，在父类中必须存在；否则编译错误(不能访问子类特有成员)
2.多态时，访问被子类覆盖的成员属性--访问的是父类的 编译看左边，运行看左边 Person p = new Student();
System.out.println(p.num1);
多态时，访问被子类重写的成员方法--访问的是子类的 编译看左边，运行看右边 Person p = new Student();
p.show();//访问的是子类的
多态时，访问的静态方法--访问的是父类的 编译看左边，运行看左边
1.6 static特点
static是静态修饰符，一般修饰成员。被static修饰的成员属于类，不属于单个这个类的某个对象。
static修饰的成员被多个对象共享。
static修饰的成员属于类，但是会影响每一个对象。
被static修饰的成员又叫类成员，不叫对象的成员。
1.7 2.静态代码块
静态代码块是定义在成员位置，使用static修饰的代码块。
特点：
l 它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。
l 该类不管创建多少对象，静态代码块只执行一次。
l 可用于给静态变量赋值，用来给类进行初始化。
public class Person {
private String name;
private int age;
//静态代码块
static{
System.out.println("静态代码块执行了");
}
}
四种访问权限修饰符
l 要想仅能在本类中访问使用private修饰；
l 要想本包中的类都可以访问不加修饰符即可；
l 要想本包中的类与其他包中的子类可以访问使用protected修饰
l 要想所有包中的所有类都可以访问使用public修饰。
l 注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
3.
04.面向对象_static关键字_注意实现_静态代码块00000000000000000000000000000000000000000000000
1).static关键字的注意事项：
1).一个类中的"静态成员"和"普通成员"分配内存空间的时机是不一样的。
"静态成员"无论任何情况下，都比"普通成员"先分配内存。
"静态成员"是在"第一次使用这个类"的时候，就会被分配空间。
2).在静态的方法内，不能直接访问"非静态成员"；只能访问"静态成员"；
在普通的方法内，可以访问静态成员和普通成员；
3).在静态方法内，不能使用this和super关键字；（this和super是在创建对象时，JVM才会为其赋值）
2).静态成员如果使用"构造方法"初始化有些晚了。
可以使用静态代码块为静态成员属性初始化。
3).静态代码块是定义在"类体中"：
class Student{
static String schoolName;
static{
schoolName = "传智播客北京校区";
}
}
4).静态代码块只在"第一次使用这个类"的时候被执行一次，之后再也不会被执行了。
5).静态代码块的作用：初始化静态成员；
4.
一个问题：abstract关键字不能和哪些关键字共存？
1).final : 因为final类不能被继承，而abstract类就是被继承的；方法也是一样；所以冲突；
2).private : abstract方法就是被子类重写的。private的方法不能被继承，也就不能被重写，所以冲突；
3).static : static方法第一次使用这个类时就要被分配空间，abstract的方法没有方法体，无法被分配空间；所以冲突；
另一个问题：当对于"成员变量"，如果被修饰为static，很有可能也需要被修饰为final
class Student{
static final String schoolName = "传智播客北京校区";
}
1.1 接口概念
接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。
接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。
请记住：一切事物均有功能，即一切事物均有接口。
1.1 接口中成员的特点
1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解static与final关键字
2、接口中可以定义方法，方法也有固定的修饰符，public abstract
3、接口不可以创建对象。
4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。
1.8 Day04面向对象
这时就会想，那么我们能不能不创建对象，就可以调用方法呢？
static是静态修饰符，一般修饰成员。被static修饰的成员属于类，不属于单个这个类的某个对象。
static修饰的成员被多个对象共享。
static修饰的成员属于类，但是会影响每一个对象。
被static修饰的成员又叫类成员，不叫对象的成员。
2.静态代码块是定义在成员位置，使用static修饰的代码块。
特点：
l 它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。
l 该类不管创建多少对象，静态代码块只执行一次。
l 可用于给静态变量赋值，用来给类进行初始化。
l 3.要想仅能在本类中访问使用private修饰；
l 要想本包中的类都可以访问不加修饰符即可；
l 要想本包中的类与其他包中的子类可以访问使用protected修饰
l 要想所有包中的所有类都可以访问使用public修饰。
l 注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
所以多态的存在意义(优点)为：
配合继承与方法重写提高了代码的复用性与扩展性，如果没有方法重写，则多态同样没有意义。
多态的弊端: 不能调用子类的特有方法
- String str =new String(“hello”) 上面语句中变量str放在栈上, 用new创建出来的字符串对象放在堆上,而 hello 这个字面量是放在方法区的
第1章 四种访问权限修饰符
在Java中提供了四种访问权限，使用不同的访问权限时，被修饰的内容会有不同的访问权限，以下表来说明不同权限的访问能力：
|
public |
protected |
空的(default) |
private |
|
|
同一类中 |
√ |
√ |
√ |
√ |
|
同一包中(子类与无关类) |
√ |
√ |
√ |
|
|
不同包的子类 |
√ |
√ |
||
|
不同包中的无关类 |
√ |
归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问
l 要想仅能在本类中访问使用private修饰；
l 要想本包中的类都可以访问不加修饰符即可；
l 要想本包中的类与其他包中的子类可以访问使用protected修饰
l 要想所有包中的所有类都可以访问使用public修饰。
l 注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
l 什么时候使用内部类
在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。