类和对象续

目录

包

自定义包

包的访问权限控制

常见的包

Static成员

静态成员变量

静态成员方法

代码块 

构造块

静态块

重写 

继承

继承是啥？

父类成员访问

子类中访问父类成员变量

两者不同名

两者同名

子类中访问父类对的成员方法

super

子类构造方法

this和super

 代码块再解读

protected关键字

继承方式

 多态

向上转型：把子类所引用的对象给到父类

再说重写 

向下转型

多态的好处

---

包

自定义包

选中src右键选择new-->package，创建名字

创建好名字后在下方新建一个testwww

建完的界面就是这样滴

包的访问权限控制

在自定义包下创建新程序TestOne和一个新的包demo，在demo下再创建一个新程序TestTwo

//TestOne
package com.bitejiuyeke.www;public class TestOne {String name = "zhangsan";public static void main(String[] args) {}
}

因为封装在TestTwo中无法引用TestOne中的变量。

常见的包

1. java.lang: 系统常用基础类 (String 、 Object), 此包从 JDK1.1 后自动导入。

2. java.lang.reflflect:java 反射编程包 ;

3. java.net: 进行网络编程开发包。

4. java.sql: 进行数据库开发的支持包。

5. java.util: 是 java 提供的工具程序包。 ( 集合类等 ) 非常重要

6. java.io:I/O 编程开发包。

---

Static成员

静态成员变量

 假设学生都在一个教室上课

我们就把classroom拿出来当成静态类

public static String classroom;

特性：

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生 ( 即：随类的加载而创建，随类的卸载而销毁 )

静态成员方法

public class Student{// ...private static String classRoom = "Bit306";// ...public static String getClassRoom(){return classRoom;}
}
public class TestStudent {public static void main(String[] args) {System.out.println(Student.getClassRoom());}
}

 特性

1. 不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名 . 静态方法名 (...) 方式调用，更推荐使用后者

3. 不能在静态方法中访问任何非静态成员变量

初始化

1.就地初始化

直接赋值

2.代码块初始化

代码块 

构造块

静态块

结论：

静态代码块先执行

然后执行构造代码块

在实行对应的构造方法

静态的只执行1次  

同步代码块

这些静态代码块可以合并成一个代码块

---

重写 

    public static void main(String[] args) {Student student = new Student("张三",10);System.out.println(student);}

打印结果是

为什么会打印粗这样的结果呢？

我们control点进去println底层

valueOf底层

toString底层

我们完全可以再自己代码中重新写一个toString方法，这样系统不会调用底层的代码，而会先考虑你写的新方法

点击鼠标右键选择generate，点进去toString，系统帮你生成一段新的打印代码，利用这段代码就可以正常打印了

    @Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';//return "lalala"//这样就可以打印lalala}

这种方法叫做重写

---

    //方法1    public static int add(int a,int b) {return a+b;}//方法2public static int add(int a,int b,int c) {return a+b+c;}//方法3public static int add(int[] array) {int ret = 0;for (int x: array) {ret += x;}return ret;}public static void main(String[] args) {int[] array = {1, 2, 3, 4, 5};System.out.println(add(array));System.out.println(add(new int[]{1, 3, 4, 5, 6}));//匿名对象}

方法3还有一个更🐂的重写方法

    /*** ...可变参数* @param array* @return*/public static int add(int... array){int ret = 0;for (int x: array) {ret += x;}return ret;}

---

继承

继承是啥？

这两个类都有相同的eat方法

每个动物都有这几个共同的特点，把这些类的共性进行抽取，放到特定的类中，从而达到代码的复用效果。这种类就叫继承

抽取新建共性类Animal

class Animal{//抽取出来的类public String name;public int age;public void eat(){System.out.println(this.name + "正在吃饭");}
}

 

这里的Dog跟Animal是is-a的关系，Dog称为子类或者派生类，Animal称为父类或者基类或者超类

extends是拓展的意思，也就是继承

---

在Animal类中，访问修饰限定符只能决定访问权限，不能决定能不能被继承

所以在后面的类中，虽然name不能被访问，但是是可以继承的，提供一个get方法就能访问

---

父类成员访问

子类中访问父类成员变量

两者不同名

class Base{public int a;public int b;
}
class Derived extends Base{public int c;public void method(){a = 1;b = 2;c = 3;}
}
public class Test2{public static void main(String[] args) {Derived derived = new Derived();}
}

 这样的访问是不受限制的

---

两者同名

class Base{public int a = 9;public int b = 99;
}
class Derived extends Base{public int a = 88;public void method(){System.out.println("a: " + a);System.out.println("b: " + b);}
}

打印结果： 

当父类和子类的成员变量同名时，在子类当中使用时，优先打印子类的成员变量

总结：成员变量访问遵循就近原则，自己有优先自己的，没有再从父类中找

---

子类中访问父类对的成员方法

跟上面的成员变量访问差不多

通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到

则访问，否则编译报错。

通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同 ( 重载 ) ，根据调用

方法适传递的参数选择合适的方法访问，如果没有则报错；

---

如果子类中存在和父类相同的成员时，怎么再子类中访问父类相同名称的成员呢？

super

super在子类方法中访问父类的成员变量和方法

---

子类构造方法

回到刚才的Animal类中，构造Animal类的构造方法

Dog报错了，因为子类没有初始化父类成员，子类在构造完之前，一定要帮助父类进行初始化

圆圆和10就是对name和age的初始化

或者这样写（generate-->constructor）

    public Dog(String name, int age){super(name, age);}

super()调用父类的构造方法，帮助初始化子类从父类继承过来的成员，并不会生成父类对象

this和super

【 相同点 】

1. 都是 Java 中的关键字

2. 只能在类的非静态(main不行)方法中使用，用来访问非静态成员方法和字段

3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

【 不同点 】

1. this 是当前对象的引用，当前对象即调用实例方法的对象， super相当于是子类对象中从父类继承下来部分成员的引用

2. 在非静态成员方法中， this 用来访问本类的方法和属性， super 用来访问父类继承下来的方法和属性

3. 在构造方法中： this(...) 用于调用本类构造方法， super(...) 用于调用父类构造方法，两种调用不能同时在构造方法中出现

4. 构造方法中一定会存在 super(...) 的调用，用户没有写编译器也会增加，但是 this(...) 用户不写则没有

---

 代码块再解读

class Animal{//抽取出来的类public String name;public int age;public void eat(){System.out.println(this.name + "正在吃饭");}static {System.out.println("Animal::static{静态}");}{System.out.println("Animal::{实例}");}public Animal(String name, int age) {this.name = name;this.age = age;System.out.println("Animal(String name, int age)");}
}
//拓展
class Dog extends Animal{//狗继承了Animalstatic{System.out.println("Dog::static{静态}");}{System.out.println("Dog::{实例}");}public Dog(String name, int age){super(name, age);System.out.println("Dog(String name, int age)");}public void bark() {System.out.println(this.name+ " 正在旺旺叫！");}
}
class Test{public static void main(String[] args) {Dog dog = new Dog("圆圆",10);}
}

 打印结果是什么呢？

两个静态优先执行，父类再执行，子类最后执行

再多两行代码

        System.out.println("================");Dog dog2 = new Dog("圆圆",10);

静态的就不执行了

---

protected关键字

package demo;public class Test3 {protected int a = 19999;
}

为什么不能打印a，就算调用super也不行呢？

因为demo2里面的Test既不是Test3的子类，又与Test3处于不同包

看回之前的那张表，这张表在我一篇博客提过

JAVA类和对象_cx努力编程中的博客-CSDN博客

此时protected正好满足第四类的限制

这个表格的前提继承的父类是由public修饰的

注意：这里的public不能替换成private或者protected

---

继承方式

1.现在有一需求：当集成到某个层次上之后我们不再继承了

final是密封类，表示当前不能继承了。

final的另一个用法。下面的a只能初始化一次，成为了常量，恒等于199，再次初始化会报错。

        final int a = 199;a = 20;//errSystem.out.println(a);

final代表不可变 e.g String

2.组合（has-a/a part of关系）

class Tire{
// ...
}
// 发动机类
class Engine{
// ...
}
// 车载系统类
class VehicleSystem{
// ...
}
class Car{private Tire tire; // 可以复用轮胎中的属性和方法private Engine engine; // 可以复用发动机中的属性和方法private VehicleSystem vs; // 可以复用车载系统中的属性和方法
// ...
}
// 奔驰是汽车
class Benz extend Car{
// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}

---

 多态

同一个人对待不同人表现出不一样的形态，这可以理解为最基本的多态

条件:

1.继承关系上-->向上转型

2.子类和父类有同名的覆盖/重写方法

3.通过父类对象的引用去调用这个重写的方法

---

向上转型：把子类所引用的对象给到父类

常见的可以发生线上转型的三个时机 

//1.直接赋值/*Dog dog = new Dog("圆圆",10);animal这个引用指向dog这个引用所指向的对象;Animal animal = dog;*/Animal animal = new Dog("圆圆",10);

//2.方法的参数，传参的时候进行向上转型public static void func1(Animal animal){}public static void main(String[] args) {Dog dog = new Dog("圆圆",10);func1(dog);}

//3.返回值向上转型public static Animal func2(){Dog dog = new Dog("圆圆",10);return dog;}

---

再说重写 

当我们在Dog类中加入eat()方法

    public void eat(){System.out.println(this.name + "正在吃狗粮！");}

//Animal  public void eat(){System.out.println(this.name + "正在吃饭");}
//Testpublic static void main(String[] args) {Animal animal = new Dog("圆圆",10);animal.eat();}

打印结果是

这两个eat方法满足方法返回值一样，方法名一样，方法的参数列表一样 

在继承关系上，这两个方法关系是重写

但是在调用的时候忽然变成了调用子类的eat，这个过程叫做动态绑定

子类如果有eat方法那就调用子类的，子类没有就调用父类的

程序在编译的时候，确实调用的是Animal的eat

程序在运行时，调用了Dog的eat方法，是在这个时候才绑定方法（区分静态绑定）

---

静态绑定是什么呢？

像这种在编译的时候已经确定了调用谁，就是静态绑定

---

我们在写重写时，一般要在上面加一个注释，这个注释可以帮助你避免一些错误

 实现重写：

1.最基本的返回值参数列表，方法名必须是一样的

2.被重写的方法的访问修饰限定符在子类中要大于等于父类的

访问修饰限定符大小关系：private>default>protected>public

3.被private，static，final修饰的方法和构造方法是不能被重写的

4.被重写的方法返回值类型可以不同，但必须有父子关系，比如：

这种叫做协变类型 

重写快捷方法，鼠标右键选generate，选择要重写的方法

---

    public static void eatFun(Animal animal){animal.eat();}public static void main(String[] args) {Dog dog = new Dog("圆圆", 19);eatFun(dog);Cat cat = new Cat("咪咪", 1);eatFun(cat);}
//圆圆正在吃狗粮！
//咪咪 正在吃猫粮！

当父类引用的子类对象不一样的时候，调用这个重写的方法，所表现出来的行为是不一样的！我们把这种思想叫做多态

向下转型

我们知道dog和cat都属于animal，但是反过来，animal就一定是dog吗，这里拿一个大类去调用一个小类的方法明显不可能

我们需要强制转换类型，这也叫做向下转型，但是这种转型非常不安全

当我们使用cat类的时候就发现类型转换异常，就算强行转换也无济于事

那我如何避免用错类来向下转型呢？我们可以用instanceof

        if (animal instanceof Cat) {Cat cat = (Cat) animal;cat.miaomiao();}else{System.out.println("好吧!");}

---

多态的好处

class Rect extends Shape{@Overridepublic void draw(){System.out.println("矩形");}
}class  Triangle extends Shape{@Overridepublic void draw() {System.out.println("🔺!");}
}class Cycle extends Shape{@Overridepublic void draw() {System.out.println("圆形!");}
}public class Test {public static void main(String[] args) {Cycle cycle = new Cycle();Rect rect = new Rect();Triangle triangle = new Triangle();String[] strings = {"cycle","rect","cycle","rect","triangle"};for(String x :strings){if(x.equals("cycle")){cycle.draw();}else if (x.equals("rect")){rect.draw();}else if (x.equals("triangle")){triangle.draw();}}}
}

如果有大量的条件和循环语句，这种代码拥有圈复杂度，我们可以用多态来降低这种复杂度

    public static void drawMap(Shape shape){shape.draw();}public static void main(String[] args) {Shape[] shapes = {new Cycle(), new Rect(), new Cycle(), new Rect(), new Triangle()};for(Shape shape: shapes){shape.draw();}}

这段代码的扩展能力非常强，在上方添加一个类下面就能给你画出来