Java面向对象-中
面向对象的特征二、继承性
1.为什么要有类的继承性？（继承性的好处）
①减少代码的冗余，提高了代码的复用性
②便于功能的扩展
③为之后多态性的使用，提供了前提。
图示：
2.继承性的格式
class A extends B{}
//A：子类、派生类、subclass
//B：父类、超类、基类、superclass
3.子类继承父类以后有哪些不同？
3.1体现：一旦子类A继承父类B之后，子类A中就获取了父类B中声明的所有的属性和方法。
类中私有的结构，只因为封装性的影响，使得子类不能直接调用父类的结构而已。
3.2子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。
子类和父类的关系，不同于子集和集合的关系。
extends：延展、扩展
4.Java中继承性的说明
1.一个类可以被多个子类继承。
2.Java中类的单继承性：一个类只能有一个父类。
3.子父类是相对的概念。
4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类。
5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法。
图示：
5.java.lang.Object类的理解
1.如果我们没显式的声明一个类的父类的话，则此类继承于java.lang.Object类。
2.所有的java类（除java.lang.Object类之外都直接或间接的继承于java.lang.Object类）。
3.意味着，所有的java类具有java.lang.Object类声明的功能。
Debug调试
方法的重写
1.什么是方法的重写（override/overwrite）？
子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作。
2.应用：
重写以后，当创建子类对象以后，通过子类对象调用子父类中同名同参数的方法时，实际执行的是子类重写父类的方法。
3.举例：
class Circle{
public double findArea(){}//求面积
}
class Cylinder extends Circle{
public double findArea(){}//求表面积
}
**********************************
class Account{
public boolean withdraw(double amt){}
}
class CheckAccount extends Account{
public boolean withdraw(double amt){}
}
4.重写的规则：
方法的声明： 权限修饰符 返回值类型 方法名（形参列表） throws 异常的类型{
方法体
}
约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法。
①子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参里列表相同。
②子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
--特殊情况：子类不能重写父类中声明为private权限的方法
③返回值类型
父类被重写的方法的返回值类型为void，则子类重写的方法的返回值类型只能是void
父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
父类被重写的方法的返回值类型是基本数据类型（比如：double），则子类重写的方法的返回值类型必须是相同的基本数据类型（必须也是double）
④子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
=======================================================================
子类和父类中同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）。
5.面试题：
区分方法的重写和重载？
答：
①二者的概念
②重载和重写的具体规则
③重载：不表现为多态性。 重写：表现为多态性。
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
所以:对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”;
而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。
引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”
关键字：super
1.super关键字可以理解为：父类的
2.可以用来调用的结构：
属性、方法、构造器
3.super调用属性、方法：
①我们可以在子类的方法或构造器中，通过使用“super.属性”或“super.方法”的方法，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略“super”
②特殊情况：当子类和父类中定义了同名的属性时，我们想要在子类中调用父类中声明的属性，则必须显式的使用“super.属性”的方式，表明调用的时父类中声明的属性。
③特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用“super.方法”的方式，表示调用的时父类中被重写的方法。
4.super调用构造器
①我们可以在子类的构造器中显式的使用“super(形参列表)”的方法，调用父类中声明的指定的构造器
②“super（形参列表）”的使用，必须声明在子类构造器的首行！
③我们在类的构造器中，针对“this(形参列表)”或“super(形参列表)”只能二选一，不能同时出现。
④在构造器的首行，没有显式的声明“this(形参列表)”或“super(形参列表)”，则默认调用的是父类中空参的构造器：super（）
⑤在类的多个构造器中，至少一个类的构造器中使用了“super（形参列表）”，调用父类中的构造器。
子类对象实例化全过程
1.从结果上看：继承性
子类继承父类以后，就获取了父类中声明的属性或方法
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。
2.从过程上看：
当我们通过子类的构造器创建子类对象时，我们一定回直接或间接的调用其父类的构造器，进而调用父类的父类的构造器.......直到调用了java.lang.Object类中空参的构造器为止。
正因为加载过所有的父类的结构，所以才可以看到内存中父类中的结构，子类对象才可以考虑进行调用。
图示：
3.强调说明：
虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。
面向对象的特征三：多态性
1.多态性的理解：
可以理解为一个事物的多种形态。
2.何为多态性：
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
举例：
Person p=new Man();
Object obj=new Date();
3.多态性的使用：虚拟方法调用
有了对象的多态性以后，我们在编译器，只能调用父类中声明的方法，但在运行期，我们实际执行的时子类重写父类的方法。
总结：编译，看左边；运行，看右边。
4.多态性的使用前提：
①类的继承性②方法的重写
5.多态性的应用举例：
举例一：
public void func(Animal animal){//Animal animal=new Dog();
animal.eat();
animal.shout();
}
举例二：
public void method(Objcet obj){
}
举例三：
class Driver{
public void doData(Connection conn){//conn =new MySQlconnection();/conn =new OracleConnection();
//规范的步骤去操作数据
//conn.method1();
//conn.method2();
//conn.method3();
}
}
6.多态性使用的注意点：
对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
7.关于向上转型与向下转型：
7.1向上转型：多态
7.2向下转型：
7.2.1为什么使用向下转型：
有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。如何才能调用子类特有的属性和方法？使用向下转型。
7.2.2如何实现向下转型：
使用强转类型转换符：（）
7.2.3使用时的注意点：
①使用强转时，可能会出现ClassCastException异常
②为了避免在向下转型时出现ClassCastException异常，我们在向下转型之前，先进性instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
7.2.4 instanceof的使用
①a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false;
②如果a instanceof A返回true，则a instancof B也返回true,其中，类B是类A的父类。
③要求a所属的类与类A必须是子类和父类的关系，否则编译报错。
7.2.5图示：
8.面试题：
8.1谈谈你对多态性的理解？
①实现代码的通用性。
②Object类中定义的public boolean equals(Object obj){}
JDBC:使用Java程序去操作（获取数据库连接、CRUD增删改查）数据库(MySQL、Oracle、DB2、SQL、Server)
③抽象类、接口的使用肯定体现了多态性。（抽象类、接口不能实例化）
8.2多态是编译时行为还是运行时行为？
运行时行为。
Object类的使用
1.java.lang.Object类的说明
①Object类是所有Java类的根父类
②如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
③Object类中的功能（属性、方法）就具通用性。
属性：无；
方法：equals()/toString()/getClass()/hashCode()/clone()/finalize()
wait()、notify()、notifyAll()
④Object类只声明了一个空参的构造器
2.equals()方法
2.1equals（）的使用：
①是一个方法，而非运算符
②只能适用于引用数据类型
③Object类中equals（）的定义：
public boolean equals(Object obj){
return (this==obj);
}
说明：Object类中定义的equals（）和==的作用是相同的：比较两个对象的地址值是否相同，即两个引用是否指向同一个对象实物。
④像String、Date、File、包装类等都重写了Object类中的equals（）方法，重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象 的”实体内容“是否相同。
⑤通常情况下，我们自定义的类如果使用equals（）的话，也通常是比较两个对象的”实体内容“是否相同。那么，我们就需要对Object类中的equals()进行重写。
重写的原则：比较两个对象的实体内容是否相同。
2.2如何重写equals()
2.2.1手动重写举例：
class User{
String name;
int age;
//重写其equals（）方法
public boolean equals(Object obj){
if(obj==this){
return true;
}
if(obj instanceof User){
User u=(User)obj;
return this.age==u.age&&this.name.equals(u.name);
}
return false;
}
}
2.2.2开发中如何实现：
自动生成的。
2.3回顾==运算符的使用：
==：运算符
①可以使用在基本数据类型变量和引用数据类型变量中
②如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同，自动类型提升）
如果比较的是引用数据类型变量：比较两个对象的地址值是否相同，即两个引用是否指向同一个对象实体。
补充：==符号使用时，必须保证符号左右两边的变量类型一致。
3.toString（）方法
3.1toString()方法的使用：
①当我们输出一个对象的引用时，实际上就是调用当前对象的toString();（除了当前对象为null）
String s="abc";
s=null;
System.out.println(s);//null
System.out,println(s.toString);//NullPointerException
//源码
public void print(String s){
if(s==null){ //当对象为null时，避免报错,将null变为字符串"null"
s="null";
}
write(s);
}
②Object类中toString的定义：
public String toString(){
return getClass().getName()+"@"+Integer.toHexString(hashCode());
}
③像String、Date、File、包装类等都重写了Object类中的toString（）方法。
使得在调用对象的toString()方法，返回”实体内容“信息
④自定义类也可以重写toString()方法，当调用此方法时，返回对象的”实体内容“。
3.2如何重写toString
自动生成。
举例：
//自动实现
@Override
public String toString(){
return "Customer[name="+name+",age="+age+"]";
}
4.面试题：
①final、finally、finalize的区别？
②==和equals（）的区别？
单元测试方法
ava中的JUnit单元测试
步骤:1.选中当前工程–右键选择: build path - add libraries -JUnit 4 -下一步
2.创建]ava类,进行单元测试。
此时的Java类要求:①此类是public的②此类提供公共的无参的构造器
3.此类中声明单元测试方法。
此时的单元测试方法:方法的权限是public,没返回值，没形参
4.此单元测试方法上需要声明注解: @Test,并在单元测试类中导入: import org.junit.Test;
5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。
6.写完代码以后，左键双击单元测试方法名，右键: run as - JUnit Test
说明:
1.如果执行结果没任何异常:绿条
2.如果执行结果出现异常:红条
包装类的使用
1.为什么要有包装类（或封装类）
为了使基本数据类型的变量具有类的特征，引入包装类。
2.基本数据类型与对应的包装类：
3.需要掌握的类型间的转换：（基本数据类型、包装类、String)
简易版：
基本数据类型<--->包装类：JDK 5.0新特性：自动装箱、自动拆箱
基本数据类型、包装类--->:String:调用String重载的valueOf(Xxx xxx);
float f1=12.3f;
String str2=String.valueOf(f1);//"12.3"
System.out.println(str2);
String--->基本数据类型、包装类:调用包装类的parseXxx(String s);
String str1="123";
int num2=Integer.parseInt(str1);
System.out.println(num2+1);
String str2="true";
boolean b1=Boolean.parseBoolean(str2);
System.out.println(b1);
注意：转换时，可能会报NumberFormatException
//报异常，字符串里不是存粹的数字
// Integer in3=new Integer("123abc");
// System.out.println(in3.toString());
应用场景举例：
①Vector类中关于添加元素，只定义了形参为Object类型的方法：
v.addElement(Object obj);//基本数据类型-->包装类-->使用多态
标签：调用,JAVA,重写,Object,面向对象,子类,父类,方法 From： https://www.cnblogs.com/nebun/p/16721276.html