目录
01.继承性的使用和理解
为什么要有继承？
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，
那么多个类无需再定义这些属性和行为，只要继承那个类即可。
一、继承性的好处
① 减少了代码的冗余，提高了代码的复用性；
② 便于功能的扩展；
③ 为之后多态性的使用，提供了前提。
二、继承性的格式
class A extends B{}
A:子类、派生类、subclass
B:父类、超类、基类、superclass
2.1 体现：一旦子类 A 继承父类以后，子类 A 中就获取了父类 B 中声明的结构：属性、方法。特别的，父类中声明为 private 的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为封装性的影响，使得子类不能直接调用父类的结构而已
2.2 子类继承父类以后，还可以声明自己特有的属性或方法，实现功能的拓展。
子类和父类的关系：不同于子集与集合的关系。
extends:延展、扩展
三、Java 中关于继承性的规定：
1.一个类可以被多个类继承
2.Java 中类的单继承性：一个类只能有一个父类
3.子父类是相对的概念。
4.子类直接继承的父类，称为：直接父类。间接继承的父类，称为，间接父类。
5.子类继承父类后，就获取了直接父类以及所有间接父类中声明的属性和方法。
四、
1.如果我们没有显式的声明一个类的父类的话，则此类继承于 java.lang.Object 类
2.所有的 java 类(除 java.long.Object 类之外)都直接或间接地继承于 java.lang.Object 类;
3.意味着，所有的 java 类具有 java.lang.Object 类声明的功能。
1、Person 类
/*
* 为描述和处理个人信息，定义类 Person
*/
public class Person {
String name;
private int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("吃饭");
sleep();
}
private void sleep(){
System.out.println("睡觉");
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
2.Student 类
/*
* 为描述和处理学生信息，定义类 Student
*/
public class Student extends Person {
// String name;
// int age;
String major;
public Student(){
}
public Student(String name,int age,String major){
this.name = name;
// this.age = age;
setAge(age);
this.major = major;
}
// public void eat(){
// System.out.println("吃饭");
// }
//
// public void sleep(){
// System.out.println("睡觉");
// }
public void study(){
System.out.println("学习");
}
public void show(){
System.out.println("name:" + name + ",age = " + getAge());
}
}
3、测试类
public class ExtendsTest {
public static void main(String[] args) {
Person p1 = new Person();
// p1.age = 1;
p1.eat();
System.out.println("********************");
Student s1 = new Student();
s1.eat();
// s1.sleep();
s1.name = "Tom";
s1.setAge(10);
System.out.println(s1.getAge());
}
}
02. 方法的重写(override/overwrite)
方法的重写(override/overwrite)
1.重写：子类继承父类以后，可以对父类中同名同参数的方法进行，覆盖操作。
2.应用：重写以后，当创建子类对象以后，通过子类对象去调用子父类中同名同参数方法时，执行的是子类重写父类的方法。即在程序执行时，子类的方法将覆盖父类的方法
面试题：区分方法的重载与重写(有的书也叫做“覆盖”)
答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。
3.重写的规定：
方法的声明：权限修饰符 返回值类型 方法名(形参列表){//方法体 }
约定俗称:子类中的叫重写的方法，父类中的叫被重写的方法。
① 子类重写的方法的方法名和形参列表必须和父类被重写的方法的方法名、形参列表相同;
② 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限,
特殊情况: 子类不能重写父类中声明为private权限的方法;
③ 返回值类型:
父类被重写的方法的返回值类型是void,则子类重写的方法的返回值类型只能是void;父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类;父类被重写的方法的返回值类型如果是基本数据类型(比如:double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须是:double)。④ 子类方法抛出的异常不能大于父类被重写的方法抛出的异常;
注意：子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。
03.四种访问权限修饰符
- 在不同包的子类中，不能调用Order类中声明为private和缺省的权限的属性、方法
- 不同包下的普通类(非子类)要使用Order类，不可以调用声明为private、缺省、protected权限的属性、方法。
04.关键字：super
super关键字的使用
1.super理解为:父类的
2.super可以用来调用:属性、方法、构造器
3.super的使用
3.1 我们可以在子类的方法或构造器中,通过"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯去省略这个"super."
3.2 特殊情况:当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性
3.3 特殊情况:当子类重写了父类中的方法后，我们想在子类的方法中调用父类中被重写的方法时，必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
4.super调用构造器
4.1 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式,调用父类中声明的指定的构造器
4.2"super(形参列表)"的使用，必须声明在子类构造器的首行！
4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)“只能二选一，不能同时出现。
4.4在构造器的首行，既没有显式的声明"this(形参列表)"或"super(形参列表)",则默认的调用的是父类中的空参构造器。super()
4.5 在类的多个构造器中，至少有一个类的构造器使用了"super(形参列表)”,调用父类中的构造器。
05.子类对象实例化过程
子类对象实例化的全过程
1.从结果上看:
子类继承父类以后，就获取了父类中声明的属性或方法。创建子类的对象中，在堆空间中，就会加载所有父类中声明的属性。
2.从过程上看:
当我们通过子类的构造器创建子类对象时,我们一定会直接或间接的调用其父类构造器,直到调用java.lang.Object类中空参的构造器为止。正因为加载过所有的父类结构，所以才可以看到内存中有父类中的结构，子类对象可以考虑进行调用。
明确:虽然创建子类对象时，调用了父类的构造器，但自始至终就创建过一个对象，即为new的子类对象。
06、面向对象特征之三：多态性
面向对象之三:多态性
1.理解多态性:可以理解为一个事物的多种态性。
2.何为多态性:
对象的多态性:父类的引用指向子类的对象(或子类的对象赋值给父类的引用)
3.多态的使用：虚拟方法调用
有了对象多态性以后，我们在编译期，只能调用父类声明的方法，但在执行期实际执行的是子类重写父类的方法
简称：编译时，看左边；运行时，看右边。
若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
多态情况下，
看左边”：看的是父类的引用（父类中不具备子类特有的方法）
“看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
4.多态性的使用前提：
① 类的继承关系
② 方法的重写
5.对象的多态性:只适用于方法，不适用于属性(编译和运行都看左边)
Person类
public class Person {
String name;
int age;
public void eat(){
System.out.println("人，吃饭");
}
public void walk(){
System.out.println("人，走路");
}
}
Woman类
public class Woman extends Person{
boolean isBeauty;
public void goShopping(){
System.out.println("女人喜欢购物");
}
public void eat(){
System.out.println("女人少吃，为了减肥。");
}
public void walk(){
System.out.println("女人，窈窕的走路。");
}
}
Man类
public class Man extends Person{
boolean isSmoking;
public void earnMoney(){
System.out.println("男人负责工作养家");
}
public void eat() {
System.out.println("男人多吃肉，长肌肉");
}
public void walk() {
System.out.println("男人霸气的走路");
}
}
测试类
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.eat();
Man man = new Man();
man.eat();
man.age = 25;
man.earnMoney();
//************************************
//对象的多态性，父类的引用指向子类的对象
Person p2 = new Man();
// Person p3 = new Woman();
//多态的使用:当调用子父类同名同参数方法时，实际调用的是子类重写父类的方法---虚拟方法调用
p2.eat();
p2.walk();
// p2.earnMoney();
}
}
举例
/*
* 多态性应用举例
*/
public class AnimalTest {
public static void main(String[] args) {
AnimalTest test = new AnimalTest();
test.func(new Dog());
test.func(new Cat());
}
public void func(Animal animal){ //Animal animal = new Dog();
animal.eat();
animal.shout();
}
//如果没有多态性，就会写很多如下的方法，去调用
public void func(Dog dog){
dog.eat();
dog.shout();
}
public void func(Cat cat){
cat.eat();
cat.shout();
}
}
class Animal{
public void eat(){
System.out.println("动物，进食");
}
public void shout(){
System.out.println("动物：叫");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃骨头");
}
public void shout() {
System.out.println("汪！汪！汪！");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
public void shout() {
System.out.println("喵！喵！喵！");
}
}
6.1.虚拟方法的补充
import java.util.Random;
/*
* 2.从编译和运行的角度看：
* 重载，是指允许存在多个同名方法，而这些方法的参数不同。
* 编译器根据方法不同的参数表，对同名方法的名称做修饰。
* 对于编译器而言，这些同名方法就成了不同的方法。
* 它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，
* 即子类可以重载父类的同名不同参数的方法。所以：对于重载而言，在方法调用之前，
* 编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
* 而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，
* 这称为“晚绑定”或“动态绑定”。
*
* 引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”
*/
//面试题：多态是编译时行为还是运行时行为？
//证明如下：
class Animal {
protected void eat() {
System.out.println("animal eat food");
}
}
class Cat extends Animal {
protected void eat() {
System.out.println("cat eat fish");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("Dog eat bone");
}
}
class Sheep extends Animal {
public void eat() {
System.out.println("Sheep eat grass");
}
}
public class InterviewTest {
public static Animal getInstance(int key) {
switch (key) {
case 0:
return new Cat ();
case 1:
return new Dog ();
default:
return new Sheep ();
}
}
public static void main(String[] args) {
int key = new Random().nextInt(3);
System.out.println(key);
Animal animal = getInstance(key);
animal.eat();
}
}
6.2、向下转型的使用
instanceof关键字的使用
- a instanceof A:判断对象a是否是类A的实例。如果，返回true，如果不是，返回false;
- 使用情境:为了避免在向下转型时出现ClassCastException异常，我们在进行向下转型之前，先进行 instanceof的判断,一旦返回true,就进行向下转型。如果返回false，不进行向下转型。
- 如果a instanceof A返回true,则a instanceof B也返回true。 其中类B是类A的父类。
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.eat();
Man man = new Man();
man.eat();
man.age = 25;
man.earnMoney();
// ************************************
System.out.println("************************");
// 对象的多态性，父类的引用指向子类的对象
Person p2 = new Man();
// Person p3 = new Woman();
// 多态的使用:当调用子父类同名同参数方法时，实际调用的是子类重写父类的方法---虚拟方法调用
p2.eat();
p2.walk();
System.out.println("**************************");
// 不能调用子类所特有的方法、属性，编译时，p2是Person类型，
// p2.earnMoney();
p2.name = "Tom";
// p2.isSmoking = true;
// 有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法，但是由于变量声明为父类类型，导致
// 编译时，只能调用父类中声明的属性和方法。子类的属性和方法不能调用。
// 如何才能调用子类所特有的属性和方法？
// 使用强制类型转换符，也可称为:向下转型
Man m1 = (Man) p2;
m1.earnMoney();
m1.isSmoking = true;
// 使用强转时，可能出现ClassCastException异常
// Woman w1 = (Woman)p2;
// w1.goShopping();
/*
* instanceof关键字的使用
*
* a instanceof A:判断对象a是否是类A的实例。如果，返回true，如果不是，返回false;
*
* 使用情境:为了避免在向下转型时出现ClassCastException异常，我们在进行向下转型之前，先进行
* instanceof的判断,一旦返回true,就进行向下转型。如果返回false，不进行向下转型。
*
* 如果a instanceof A返回true,则a instanceof B也返回true。 其中类B是类A的父类。
*
*/
if (p2 instanceof Woman) {
Woman w1 = (Woman) p2;
w1.goShopping();
System.out.println("**********Woman*********");
}
if (p2 instanceof Man) {
Man m2 = (Man) p2;
m2.earnMoney();
System.out.println("*********Man************");
}
if (p2 instanceof Person) {
System.out.println("***********Person************");
}
if (p2 instanceof Object) {
System.out.println("***********object************");
}
//向下转型的常见问题
//练习
//问题1:编译时通过，运行时不通过
//举例一
// Person p3 = new Woman();
// Man m3 = (Man)p3;
//举例二
Person p4 = new Person();
Man m4 = (Man)p4;
//问题二:编译通过，运行时也通过
Object obj = new Woman();
Person p = (Person)obj;
//问题三:编译不通过
// Man m5 = new woman();
// String str = new Date();
// Object o = new Date();
// String str1 = (String)o;
}
}
07.Object 类的使用
java.lang.Object类
1.Object类是所有Java类的根父类;
2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
3.Object类中的功能(属性、方法)就具有通用性。
属性:无
方法:equals() / toString() / getClass() / hashCode() / clone() /finalize()/wait() /notify()/notifyAll()
4.Object类只声明了一个空参的构造器。
7.1、Object类中的主要结构
7.2、==操作符与equals方法
一、回顾 ==的使用(运算符)
1.可以使用在基本数据类型变量和引用数据类型变量中
2.如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。(不一定类型要相同)如果比较的是引用数据类型变量：比较两个对象的地址值是否相同,即两个引用是否指向同一个对象实体
补充: == 符号使用时，必须保证符号左右两边的变量类型一致。
二、equals()方法的使用
1.是一个方法，而非运算符
2.只能适用于引用数据类型。
说明：Object类中定义的equals()和 ==的作用是相同的，比较两个对象的地址值是否相同，即两个引用是否指向同一个对象实体。
4.像String、Date、File、包装类等都重写了Object类中的equals()方法.重写以后，比较的就不是两个引用的地址是否相同，而是比较两个对象的“实体内容”是否相同。
5.通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写。
重写的原则:比较两个对象的实体内容是否相同。
7.3、toString的使用
import java.util.Date;
/*
* Object类中toString()的使用
*
* 1.当我们输出一个引用对象时，实际上就是调用当前对象的toString()
* 2.Object类中toString的定义方法
* public String toString() {
* return getClass().getName() + "@" + Integer.toHexString(hashCode());
* }
*
* 3.像String、Date、File、包装类等都重写了Object类中的toString()方法。
* 使得在调用toString()时，返回"实体内容"信息.
*
* 4.自定义类如果重写toString()方法，当调用此方法时，返回对象的"实体内容".
*/
public class ToStringTest {
public static void main(String[] args) {
Customer cust1 = new Customer("Tom" ,21);
System.out.println(cust1.toString()); //github4.Customer@15db9742
System.out.println(cust1); //github4.Customer@15db9742 ---> Customer[name = Tom,age = 21]
String str = new String("MM");
System.out.println(str);
Date date = new Date(45362348664663L);
System.out.println(date.toString()); //Wed Jun 24 12:24:24 CST 3407
}
}
08、包装类(Wrapper)的使用
/*
* 包装类的使用
* 1.java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
* 基本数据类型 包装类
* byte Byte
* short Short
* int Integer
* long Long
* float Float
* double Double
* boolean Boolean
* char Character
* 注意:其中Byte、Short、Integer、Long、Float、Double的父类是:Number
* /
import org.junit.Test;
/*
* 2.基本数据类型、包装类、String三者之间的相互转换。
*
*/
public class WrapperTest {
//String类型---> 基本数据类型、包装类,调用包装类的parseXxx()
@Test
public void test5(){
String str1 = "123";
// String str1 = "123a";
//错误的情况，可能会报错
// int num1 = (int)str1;
// Integer in1 = (Integer)str1;
int num2 = Integer.parseInt(str1);
System.out.println(num2 + 1); //124
String str2 = "true";
Boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1); //true
}
//基本数据类型、包装类---》String类型，调用String重载的valueOf(Xxx xxx)
@Test
public void test4(){
int num1 = 10;
//方式1:连接运算
String str1 = num1 + "";
//方式2:调用String的valueOf(Xxx xxx)
float f1 = 12.3f;
String str2 = String.valueOf(f1); //"12.3"
Double d1 = new Double(12.4);
String str3 = String.valueOf(d1);
System.out.println(str2);
System.out.println(str3); //"12.4"
}
/*
* JDK 5.0 新特性:自动装箱与自动拆箱
*/
@Test
public void test3(){
// int num1 = 10;
// //基本数据类型 --》 包装类的对象
// method(num1); //Object obj = num1
//自动装箱:基本数据类型 --》 包装类
int num2 = 10;
Integer in1 = num2;//自动装箱
boolean b1 = true;
Boolean b2 = b1;//自动装箱
//自动拆箱：包装类 --》 基本数据类型
System.out.println(in1.toString());
int num3 = in1;
}
public void method(Object obj){
System.out.println(obj);
}
//包装类 --》 基本数据类型:调用包装类的xxxValue()
@Test
public void test2() {
Integer in1 = new Integer(12);
int i1 = in1.intValue();
System.out.println(i1 + 1);
Float f1 = new Float(12.3f);
float f2 = f1.floatValue();
System.out.println(f2 + 1);
}
//基本数据类型--》包装类,调用包装类的构造器
@Test
public void test1() {
int num1 = 10;
// System.out.println(num1.toString());
Integer in1 = new Integer(num1);
System.out.println(in1.toString());
Integer in2 = new Integer("123");
System.out.println(in2.toString());
//报异常
// Integer in3 = new Integer("123abc");
// System.out.println(in3.toString());
Float f1 = new Float(12.3f);
Float f2 = new Float("12.3");
System.out.println(f1);
System.out.println(f2);
Boolean b1 = new Boolean(true);
Boolean b2 = new Boolean("true");
Boolean b3 = new Boolean("true123");
System.out.println(b3); //false
Order order = new Order();
System.out.println(order.isMale); //false
System.out.println(order.isFemale); //null
}
}
class Order{
boolean isMale;
Boolean isFemale;
}
2265
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
