第5章 面向对象（上）
5.1 类和对象
类可以当成是一种自定义类型，可以使用类来定义变量。这种类型变量称为引用变量。
5.1.1 定义类
[修饰符] class 类名
{
构造器
成员变量
方法
}
各成员之间的定义顺序没有任何影响，各成员之间可以相互调用。
@static成员不能调用非static 成员。
成员变量用于定义类包含的状态数据，方法用于定义类的行为或功能实现。构造器用于构造类的实例，java通过new调用构造器，返回类的实例。
定义成员变量的语法：
[修饰符] 类型 成员变量名 [=默认值];
定义方法的语法：
[修饰符] 返回值类型 方法名(形参列表)
{//方法体}
定义构造器的语法
[修饰符] 构造器名(形参列表)
{}
构造器名必须和类名相同
@static 是一个特殊的关键字，static修饰的成员表明它属于这个类本身，而不属于类的单个实例。
定义一个Person类：
public class Person { public String name; public int age; public void say(String content){ System.out.println(content); } }
Person没有定义构造器，系统为它提供默认构造器。
5.1.2 对象的产生和使用
创建对象的途径是构造器，通过new即可调用构造器来创建实例。
Person p;
p = new Person();
@可以简写为 Person p = new Person();
使用对象：
1、访问对象的实例变量
2、调用对象的方法
p.name = “李刚”;
p.say(“Java很简单”);
@static修饰的方法和变量，既可以通过类来调用，也可以通过实例来调用。
5.1.3 对象、引用和指针
和数组类似，类也是一种引用类型。
Person p2 = p; 其实是将p的地址赋值给p2,p2和p指向的是同一个Person对象。
5.1.4 对象的this引用
this关键字总是指向调用该方法的对象。
this的使用有两种情形：
1、构造器中引用该构造器正在初始化的对象
2、在方法中引用调用该方法的对象。
this最大的作用就是让类中的一个方法，访问该类的另一个方法或实例变量。
假设有一个Dog类
Dog类有jump()方法,现在定义一个run()方法，要在run()方法中调用jump()
public void run(){
this,jump();
}
@java允许对象的一个成员直接调用另一个成员，可以省略this前缀
当方法中的某个局部变量和成员变量同名时，要使用被覆盖的成员变量，就要使用this前缀。
public Test{ public int foo; public Test{ int foo = 0; this.foo = 6; } }
5.2 方法详解
方法是类或对象的行为特征的抽象。从功能上看，方法完全类似于传统结构化程序设计中的函数。
5.2.1 方法的所属性
方法是类和对象的附属。体现在：
1、方法不能独立定义，只能在类中定义
2、从逻辑上看，方法要么属于类本身，要么属于类的一个对象
3、永远不能独立执行方法，执行方法必须使用类或对象作为调用者。
5.2.2 方法的参数传递机制
Java方法的参数传递方式只有一种，值传递。 //将实际参数值的副本传入方法内，参数本身不受影响
引用类型传递仍然是值传递，但传递的是引用的副本，通过操作副本来访问对象也会改变对象本身。
（因为对象就是在堆内存里的那一个对象，并没有复制另一个对象，复制的是引用变量）
5.2.3 形参个数可变的方法
定义方法时，在最后一个形参的类型后面加三点…，表明该形参可以接收多个参数值。多个参数值被当成数组传入。
public class Varargs { public static void test(int a, String… books) { for(String tmp : books) { System.out.println(tmp); } System.out.println(a); } }
5.2.4 递归方法
方法调用自身，构成递归。
5.2.5 方法重载
Java允许一个类里里定义多个同名方法，只要形参列表不同就行。
如果一个类包含多个同名方法，则称为方法重载。
5.3 成员变量和局部变量
5.3.1 成员变量和局部变量
成员变量值在类里定义的变量，局部变量是在方法里定义的变量。
成员变量分为类变量和实例变量两种，定义成员变量时没有static修饰时就是实例变量，有static修饰就是类变量。
类变量在该类的准备阶段起就存在，直到系统完全销毁这个类，类变量的作用域和类的生存范围相同。
而实例变量则时从实例创建起存在，直到实例被销毁。
@成员变量无需显式初始化。系统会默认初始化。
局部变量根据定义形式不同，可以被分成3种。
形参，方法局部变量，代码块局部变量。
局部变量除了形参之外，都必须显式初始化。
5.3.2 成员变量初始化和内存中的运行机制
系统加载类或创建类的实例时，自动为成员变量分配内存空间，指定初始值。
5.3.3 局部变量的初始化和内存中的运行机制
局部变量定义后，必须经过显式初始化才能使用，系统不会为局部变量执行初始化。
定义局部变量后，系统并未为这个变量分配内存空间，知道赋初始值时，才分配内存。
局部变量不属于类或实例，因此它总是保存在其方法的栈内存中。
5.3.4 变量的使用规则
应该使用成员变量的情形：
1、变量用于描述某个类或对象的属性，比如人的身高，体重，应该使用成员变量。
如果是类相关，比如人的眼睛数量，应该所有人的眼睛都是2个，则应该定义为类变量。
2、变量用来保存类或实例的状态信息。比如五子棋的棋盘数组。
3、变量需要在多个方法间共享。
如果可能，尽量缩小局部变量的范围，节约内存的使用。
5.4 隐藏和封装
5.4.1 理解封装
封装指将对象的状态信息隐藏在对象内部，不允许外界直接访问对象内部信息，而是通过类提供的方法来实现对内部信息的操作和访问。
5.4..2 使用访问控制符
Java提供3个访问控制符：private protected public，代表3个访问控制级别。
另外还有一个默认的级别。
private（当前类访问权限）
default（包访问权限）
protected（子类访问权限）
public（公共访问权限）
@如果一个Java源文件没有publc 类，则Java源文件文件名可以是任意的。如果有public类，则文件名必须和public修饰的类名相同
实例：（使用封装的）Person类
public class Person { private String name; private int age; public void setName(String name){ if(name.length()>6 || name.length()<2){ System.out.println("人名不符合要求"); return; } else{ this.name = name; } } public String getName(){ return this.name; } public void setAge(int age){ if(age>100 || age<0){ System.out.println("年龄不合法"); return; } else{ this.age = age; } } public int getAge(){ return this.age; } }
类外，只能使用setter和getter方法来访问Person的属性。
@关于控制访问符
1、类里的绝大部分成员变量都应该使用private修饰，只有一些static修饰的，类似全局变量的成员变量才考虑public。
此外，有些方法只用于辅助其他方法的实现，称为工具方法，也应该用private修饰。
2、如果这个类将作为其他类的父类，里面的方法希望子类重写，而不希望外界调用，应该用protected修饰这些方法。
3、希望暴露给其他类的应该用public。因此，类的构造器应该用public修饰，允许其他地方创建类的实例。
5.4.3 package、import和import static
package用来解决重名问题
Java允许将一组相关的类放在一个package下，构成逻辑上的类库单元。
如果希望将一个类放在指定的包下，应该在源程序的第一个非注释行写下：
package packageName;
则这个文件的类都属于这个包。其他人使用该包下的类时，应该使用包名加类名。
将Hello 放在lee包下：
package lee; public class Hello { public static void main(String[] args){ System.out.println("Hello, world!"); } }
使用
javac -d . Hello.java 编译，则会出现一个lee文件夹，里面有Hello.class
进入lee文件夹，执行 java lee.Hello
同一个包下的类可以自由访问，无需添加包前缀。
import 语句：
为了避免繁琐的前缀，Java引入了import关键字
import package.subpackage,,,ClassName;
@使用*表示全部类
一旦import导入某些类，就可以省略包前缀。
静态导入：
导入指定类的某个静态成员变量、方法。
语法:
import static package.subpackage…ClassName.fieldName|methodName;
5.4.4 Java的常用包
Java核心类都放在Java包及其子包下，Java许多扩展类都放在javax包及其子包下。
5.5 深入构造器
5.5.1 使用构造器执行初始化
构造器最大的作用就是创建对象时执行初始化。
public class ConstructorTest { public String name; public int count; public ConstructorTest(String name,int count){ this.name = name; this.count = count; } public static void main(String[] args){ ConstructorTest ct = new ConstructorTest("lee", 22); } }
@一旦提供自定义的构造器，系统就不再提供默认的构造器
5.5.2 构造器重载
类似方法重载
import jdk.internal.jshell.tool.resources.l10n; public class ConstructorOverload { public String name; public int count; public ConstructorOverload(){} public ConstructorOverload(String name,int count){ this.name = name; this.count= count; } public static void main(String[] args){ ConstructorOverload co1 = new ConstructorOverload(); ConstructorOverload co2 = new ConstructorOverload("java",111); } }
如果包含多个构造器，一个构造器包含另一个构造器全部的执行体。则可以用this调用.
public class Apple { public String name; public String color; public double weight; public APPle(){} public Apple(String name,String color){ this.name = name; this.color = color; } public Apple(String name,String color,double weight){ this(name,color); this.weight = weight; } }
5.6 类的继承
Java的继承是单继承，每个子类只有一个直接父类。
5.6.1 继承的特点
继承通过extends 关键字实现， 被继承的称为父类，实现继承的称为子类。
父类和子类的关系，是一般和特殊的关系，例如水果和苹果的关系。苹果是一种特殊的水果。
继承语法:
修饰符 class SubClass extends Supclass
{
…
}
extends 直译为扩展，可以体现出子类对父类的扩展。
而现在一般翻译为继承，体现子类获得父类的全部成员变量和方法。
@子类不会获得父类的构造器。
例：
public class Fruit { public double weight; public void info(){ System.out.println("我是一个水果，重"+weight+"g!"); } } public class Apple extends Fruit { public static void main(String[] args){ Apple a = new Apple(); a.weight = 56; a.info(); } }
5.6.2 重写父类的方法
大多数时候，子类以父类为基础，扩展新的成员。但有时候，子类要重写父类的方法。例：
public class Bird { public void fly(){ System.out.println("起飞..."); } } //鸵鸟 public class Ostrich extends Bird { public void fly(){ System.out.println("只能在地上跑"); } }
子类鸵鸟重写（Override）了Bird的fly()方法，重写也称覆盖。
方法重写遵循“两同两小一大”规则：
两同即方法名相同，形参列表相同； 两小指子类方法返回值类型比父类方法返回值类型 更小或相等，子类方法抛出异常比父类方法抛出的异常类更小或相等；
一大值子类方法的访问权限应该比父类方法访问权限更大或相等。
当子类覆盖父类方法后，子类对象无法访问被覆盖的父类方法，但可以在子类方法中调用父类中被覆盖的方法。使用super或父类类名作为调用者来调用被覆盖的方法。
如果父类方法使用private修饰，则对子类隐藏。
5.6.3 super限定
要在子类中方法中调用被覆盖的父类方法，可使用super限定
public class Ostrich extends Bird { public void fly(){ System.out.println("只能在地上跑"); } public void call(){ super.fly(); //调用父类方法 } }
super用于限定对象调用它从父类继承得到的实例变量或方法。
如果子类定义了和父类同名的实例变量，则会隐藏父类实例变量，通过super可以访问被隐藏的实例变量。
5.6.4 调用父类构造器
子类不会获得父类构造器，子类构造器里可以调用父类构造器的初始化代码，类似于一个构造器调用另一个重载的构造器。
在子类中调用父类父类构造器使用super调用。
class Base { public double size; public String name; public Base(double size,String name){ this.size = size; this.name = name; } } public class Sub extends Base { public String color; public Sub(double size,String name, String color){ super(size,name); //调用父类构造器 this.color = color; } }
@不管是否使用suoer调用父类构造器，子类构造器总会调用父类构造器一次。
5.7 多态
5.7.1 多态性
编译时类型由声明该变量的类型决定，运行时类型由实际赋给变量的对象决定。
如果运行和编译时类型不一致，就会出现多态（Polymorphism）。
class BaseClass { public int book = 6; public void base(){ System.out.println("父类的普通方法"); } public void test(){ System.out.println("父类的被覆盖方法"); } } public class SubClass extends BaseClass { public String book = "java"; public void test(){ System.out.println("子类覆盖父类的方法"); } public void sub(){ System.out.println("子类的普通方法"); } public static void main(String[] args){ BaseClass p = new SubClass(); p.base(); p.test(); // } }
@与方法不同，对象的实例变量不具有多态性。
5.7.2 引用变量的强制类型转换
如果要一个引用变量调用它运行时类型的方法，则需要强制类型转换成运行时类型。
强制类型转换语法：
(type) variable
强制类型转化并不都可行，因此在强制类型转换之前先通过 instanceof运算符判断是否可以转换：
if(objPri instanceof String){
String str = (String) objPri;
}
5.7.3 instanceof 运算符
前面的操作数为一个引用类型变量， 后一个操作数通常是一个类。
用于判断前面的对象是否是后面的类。
@ 前面的操作数要和后面的类有继承关系，否则会引起编译错误。
5.8 继承和组合
5.8.1 使用继承的注意点
继承带来高度复用的同时，也带来一个严重的问题：继承破坏了父类的封装性，子类可以直接访问父类的内部信息。
为了确保父类良好的封装性，设计父类应该遵循以下规则：
1、尽量隐藏父类的内部数据，尽量将父类成员设置为private。
2、不要让子类可以随意访问，修改父类的方法。父类中的（仅仅辅助其他功能实现的）工具方法，应该使用private修饰。
如果父类中方法必须为外部使用，又不想子类重写，可以使用final修饰符。 如果希望子类重写，又不希望外部类访问，可以使用protected。
3、尽量不要在父类构造器调用将要在子类中重写的方法。
@final class xx final修饰的类不能被继承
5.8.2 利用组合实现复用(has-a)
如，借助Arm类实现Person类。
5.9 初始化块
与构造器作用类似。
5.9.1 使用初始化块
初始化块是Java类中可以出现的第4种成员。一个类可以有多个初始化块，按先后顺序执行。
初始化块的语法：
[修饰符] {
//初始化块的代码
}
@修饰符可以是static，称为静态初始化块
当创建Java对象时，系统总是先调用类定义的初始化块。
5.9.2 初始化块和构造器
某种程度上，初始化块是构造器的补充，如果两个构造器都有共同的无需参数的初始化行为，则可以提取到初始化块中。
@实际上初始化块是一种假象，使用javac编译后，初始化块会被移动到每个构造器中。
5.9.3 静态初始化块
使用static修饰符的初始化块。静态初始化块是和类相关的，总是在类初始化阶段执行。
静态初始化块和声明静态成员变量时指定初始值 都是类的初始化代码，执行顺序和代码排列顺序相同。
