继承的概念
继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
生活中的继承：
兔子和羊属于食草动物类，狮子和豹属于食肉动物类。
食草动物和食肉动物又是属于动物类。
所以继承需要符合的关系是：is-a，父类更通用，子类更具体。
虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。
类的继承格式
在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：
类的继承格式
class 父类 { }
class 子类 extends 父类 { }
为什么需要继承
接下来我们通过实例来说明这个需求。
开发动物类，其中动物分别为企鹅以及老鼠，要求如下：
-
企鹅：属性（姓名，id），方法（吃，睡，自我介绍）
-
老鼠：属性（姓名，id），方法（吃，睡，自我介绍）
企鹅类：
public class Penguin {
private String name;
private int id;
public Penguin(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + ".");
}
}老鼠类：
public class Mouse {
private String name;
private int id;
public Mouse(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + ".");
}
}从这两段代码可以看出来，代码存在重复了，导致后果就是代码量大且臃肿，而且维护性不高(维护性主要是后期需要修改的时候，就需要修改很多的代码，容易出错)，所以要从根本上解决这两段代码的问题，就需要继承，将两段代码中相同的部分提取出来组成 一个父类：
公共父类：
public class Animal {
private String name;
private int id;
public Animal(String myName, int myid) {
name = myName;
id = myid;
}
public void eat(){
System.out.println(name+"正在吃");
}
public void sleep(){
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + ".");
}
}这个Animal类就可以作为一个父类，然后企鹅类和老鼠类继承这个类之后，就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性（复用性主要是可以多次使用，不用再多次写同样的代码） 继承之后的代码：
企鹅类：
public class Penguin extends Animal {
public Penguin(String myName, int myid) {
super(myName, myid);
}
}老鼠类：
public class Mouse extends Animal {
public Mouse(String myName, int myid) {
super(myName, myid);
}
}继承类型
需要注意的是 Java 不支持多继承，但支持多重继承。
继承的特性
-
子类拥有父类非 private 的属性、方法。
-
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
-
子类可以用自己的方式实现父类的方法。
-
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
-
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。
继承关键字
继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。
extends关键字
在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
extends 关键字
public class Animal {
private String name;
private int id;
public Animal(String myName, String myid) {
//初始化属性值
}
public void eat() { //吃东西方法的具体实现 }
public void sleep() { //睡觉方法的具体实现 }
} public class Penguin extends Animal{
}1.继承
1.1 继承的实现
-
继承的概念
-
继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法
-
-
实现继承的格式
-
继承通过extends实现
-
格式：class 子类 extends 父类 { }
-
举例：class Dog extends Animal { }
-
-
-
继承带来的好处
-
继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。
-
-
示例代码
public class Fu { public void show() { System.out.println("show方法被调用"); } } public class Zi extends Fu { public void method() { System.out.println("method方法被调用"); } } public class Demo { public static void main(String[] args) { //创建对象，调用方法 Fu f = new Fu(); f.show(); Zi z = new Zi(); z.method(); z.show(); } }
1.2 继承的好处和弊端(理解)
-
继承好处
-
提高了代码的复用性(多个类相同的成员可以放到同一个类中)
-
提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
-
-
继承弊端
-
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
-
-
继承的应用场景：
-
使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承
-
is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类
-
-
1.3 Java中继承的特点（掌握）
-
Java中继承的特点
-
Java中类只支持单继承，不支持多继承
-
错误范例：class A extends B, C { }
-
-
Java中类支持多层继承
-
-
多层继承示例代码：
public class Granddad {
public void drink() {
System.out.println("爷爷爱喝酒");
}
}public class Father extends Granddad {
public void smoke() {
System.out.println("爸爸爱抽烟");
}
}public class Mother {
public void dance() {
System.out.println("妈妈爱跳舞");
}
}
public class Son extends Father {
// 此时，Son类中就同时拥有drink方法以及smoke方法
}2. 继承中的成员访问特点
2.1成员的访问特点
在父子类的继承关系中,创建子类对象,创建的对象是谁,就优先用谁,如果没有就向上找 无论是成员变量还是成员方法,如果没有没有都是向上找父类,绝对不会向下找子类的
public class Fu {
int numFu=10;
int num=100;
public void methodFu(){
System.out.println(num);
}
}public class Zi extends Fu{
int numZi=20;
int num=200;
public void methodZi(){
System.out.println(num);
}
}public class Demo {
public static void main(String[] args) {
Fu fu=new Fu();
System.out.println(fu.numFu);
System.out.println(fu.num);
System.out.println("=========");
Zi zi=new Zi();
System.out.println(zi.numFu);
System.out.println(zi.numZi);
System.out.println("=========");
System.out.println(zi.num);
System.out.println("=========");
zi.methodZi();
zi.methodFu();
}
}2.2 this和supper访问成员
-
this&super关键字：
-
this：代表本类对象的引用
-
super：代表父类存储空间的标识(可以理解为父类对象引用)
-
-
this和super的使用分别
-
成员变量：
-
this.成员变量 - 访问本类成员变量
-
super.成员变量 - 访问父类成员变量
-
-
成员方法：
-
this.成员方法 - 访问本类成员方法
-
super.成员方法 - 访问父类成员方法
-
-
-
构造方法：
-
this(…) - 访问本类构造方法
-
super(…) - 访问父类构造方法
-
3. 方法重写
3.1 概述和使用
-
1、方法重写概念
-
子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
-
-
2、方法重写的应用场景
-
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
-
-
3、Override注解
-
用来检测当前的方法，是否是重写的方法，起到【校验】的作用
-
3.2 注意事项(掌握)
-
方法重写的注意事项
-
私有方法不能被重写(父类私有成员子类是不能继承的)
-
子类方法访问权限不能更低(public > 默认 > 私有)
-
静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法
-
示例代码
public class Fu { private void show() { System.out.println("Fu中show()方法被调用"); } void method() { System.out.println("Fu中method()方法被调用"); } }public class Zi extends Fu { /* 编译【出错】，子类不能重写父类私有的方法*/ @Override private void show() { System.out.println("Zi中show()方法被调用"); } /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */ @Override private void method() { System.out.println("Zi中method()方法被调用"); } /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */ @Override public void method() { System.out.println("Zi中method()方法被调用"); } }
4.权限修饰符
| 修饰符 | 同一个类中 | 同一个包中,子类无关类 | 不同包的子类 | 不同包的无关类 |
|---|---|---|---|---|
| private | √ | |||
| 默认 | √ | √ | ||
| protected | √ | √ | √ | |
| public | √ | √ | √ | √ |
5.抽象类
5.1 概述(理解)
当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！ 在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！ 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。 父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。 在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
抽象类总结规定 1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。 2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。 3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。 4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。 5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。
5.2 特点
-
抽象类和抽象方法必须使用 abstract 关键字修饰
//抽象类的定义 public abstract class 类名 {} //抽象方法的定义 public abstract void eat(); -
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
-
抽象类不能实例化
-
抽象类可以有构造方法
-
抽象类的子类
要么重写抽象类中的所有抽象方法
要么是抽象类
-
代码实现
-
动物类
-
-
public abstract class Animal {
public void drink(){
System.out.println("喝水");
}
public Animal(){
}
public abstract void eat();
}-
-
-
猫类
public class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } }-
狗类
public class Dog extends Animal { @Override public void eat() { System.out.println("狗吃肉"); } }-
测试类
public static void main(String[] args) { Dog d = new Dog(); d.eat(); d.drink(); Cat c = new Cat(); c.drink(); c.eat(); //Animal a = new Animal(); //a.eat(); } -
-
6.static关键字
6.1 概述
static 关键字是静态的意思,是Java中的一个修饰符,可以修饰成员方法,成员变量
6.2static修饰的特点
-
被类的所有对象共享
是我们判断是否使用静态关键字的条件
-
随着类的加载而加载，优先于对象存在
对象需要类被加载后，才能创建
-
可以通过类名调用
也可以通过对象名调用
6.3注意事项(理解)
-
静态方法只能访问静态的成员
-
非静态方法可以访问静态的成员，也可以访问非静态的成员
-
静态方法中是没有this关键字
7.final关键字
-
fianl关键字的作用
-
final代表最终的意思，可以修饰成员方法，成员变量，类
-
-
final修饰类、方法、变量的效果
-
fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
-
final修饰方法：该方法不能被重写
-
final修饰变量：表明该变量是一个常量，不能再次赋值
-
变量是基本类型,不能改变的是值
-
变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的
-
举例
-
public static void main(String[] args){ final Student s = new Student(23); s = new Student(24); // 错误 s.setAge(24); // 正确 } -
举例2
public final class People {
public People(){
}
}
class Man extends People {
}8.代码块
8.1代码块概述
在Java中，使用 { } 括起来的代码被称为代码块
8.2代码块分类
-
局部代码块
-
位置：在main方法中
-
作用：限定变量的生命周期，及早释放，提高内存利用率
-
-
构造代码块
-
位置：类中方法外定义
-
特点：每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行
-
作用：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
-
-
静态代码块
-
位置：类中方法外定义
-
特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
-
作用：在类加载的时候做一些数据初始化的操作
-
8.3代码块的执行优先级
-
静态代码块>构造代码块>构造方法;
public class Block {
{
System.out.println("我是构造代码块");
}
static {
System.out.println("我是静态代码块");
}
public void method(){
System.out.println("我是成员方法");
}
public Block(){
System.out.println("我是无参构造方法");
}
}public class BlockTest {
public static void main(String[] args) {
{
System.out.println("我是局部代码块");
}
Block block=new Block();
block.method();
}
}列2：
public class Person {
static{
System.out.println("1.我是静态块，优先于构造块执行！并且只有创建第一个对象的时候执行一次！");
}
{
System.out.println("2.我是构造块，优先于构造方法执行！每创建一个对象执行一次！");
}
public Person() {
System.out.println("3.我是构造方法，每创建一个对象执行一次");
}
public void function1(){
System.out.println("我是非静态方法中的普通代码块，方法被调用时执行！");
}
public static void function2(){
System.out.println("我是静态方法中的普通代码块，方法被调用时执行，晚于静态块执行！");
}
}public class HelloWrold {
public static void main(String[] args) {
new Person().function1();
new Person().function2();
/*
* 我们可以看出：静态块总是最先执行的，并且只有在创建该类的第一个实例的时候才会执行一次；
* 第二执行的是构造块；第三执行的是构造方法。
* */
}
}总结：
非私有的成员方法和成员变量；
b、子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的 构造方法
c、不要为了部分功能而去继承
1、this关键字和super关键字分别代表什么，以及他们各自的作用分别是什么？
this 关键字表示对象的引用，哪个对象来调用该类成员，就代表哪个对象
super 代表当前对象的父类的引用。1、代码块是什么，分为哪几类，各自有什么特点？
代码块是用{}括起来的语句；
分类：根据位置和声明的不同分为以下几块：
1）局部代码块：在方法中出现，限定变量生命周期，及早释放，提高内存利用率；
2）构造代码块：又叫初始化块，
在类中方法外出现，多个构造方法中相同的代码存放到一起，每次调用构造方法都执行，并且在构造方法前执行。
3）静态代码块：
* 在类中方法外出现，并加上static修饰符，用于给类进行初始化，在类加载的时候就执行，并且只执行一次；
* 一般用于加载驱动
4）同步代码块：
//构造代码块，优先于构造方法执行，主要是为了提取构造方法中必须执行的公共代码！
//构造代码块，每次创建对象时，都优先于构造方法执行！
//作用：给构造方法进行初始化！
//被static修饰的，随着类的加载而加载，静态代码块 随着类的加载而执行
//静态代码块只执行一次
//作用：用来加载特殊数据 比如：如果有些代码必须在项目启动的时候就执行，需要使用静态代码块。
/*
静态代码块，在虚拟机加载类的时候就会加载执行，而且只执行一次；
非静态代码块，在创建对象的时候（即new一个对象的时候）执行，每次创建对象都会执行一次
相同点：都是在JVM加载类时且在构造方法执行之前执行，在类中都可以定义多个，
一般在代码块中对一些static变量进行赋值。
不同点：静态代码块在非静态代码块之前执行(静态代码块—>非静态代码块—>构造方法)。
静态代码块只在第一次类加载时执行一次，之后不再执行，而非静态代码块在每new
一次就执行一次。非静态代码块可在普通方法中定义(不过作用不大)；而静态代码块不行。
*/
/*
总结：
局部代码块：在方法中出现
构造代码块：在类中方法外出现，随着对象的创建而加载，创建一次对象构造代码块执行一次
静态代码块：随着类的加载而加载，并且只执行一次（一般用于加载驱动）
主方法类中的静态代码块：优先于主方法执行
*/
2、子父类都有静态代码块、构造代码块、构造方法，那么他们六者之间的执行流程是什么？
父类静态代码块
子类静态代码块
父类构造代码块
父类构造方法
子类构造代码块
子类构造方法
3、继承的好处、弊端分别是什么？
好处：提高代码的复用性
提高代码的维护性
让类与类之间产生关系，是多态的前提
弊端：类的耦合性增强了；
开发的原则是：高内聚，低耦合
耦合是类与类的关系
内聚是自己完成某件事的能力
4、Java中继承的特点是什么？
1）java中只支持单继承，不支持多继承（一个儿子只有一个亲爹）
2）java中支持"多层"继承，也就是继承体系。
5、Java中继承的注意事项是什么？我们什么时候使用继承?
a、子类只能继承父类所有
this 的作用：
1、this.成员变量：调用本类的成员变量，也可以调用父类的成员变量
2、this(...) 调用本类的构造方法；
3、this.成员方法：调用本类的成员方法，也可以调用父类的成员方法
super 的作用
1、super.成员变量：调用父类的成员变量
2、super(...) 调用父类的构造方法；
3、super.成员方法：调用父类的成员方法。
8、继承中构造方法的执行流程是什么？
先访问父类的构造方法，再访问子类的构造方法；
9、为什么子类中所有的构造方法默认都会访问父类的空参构造？
假如父类没有无参构造方法，子类应该怎么办?
1、因为子类继承父类中的数据，也可能会使用父类的数据；
2、子类初始化前，必须要要先将父类初始化。
如果父类没有空参构造，就用this或者super来调用父类的有参构造。
10、super关键字和this关键字可以在构造方法中共存吗？
this()或者super()都必须是在构造方法中的第一行；
Java的值传递和引用传递
形参、实参
要说Java的值传递和引用传递，首先需要说明两个概念：形参和实参。
形参，就是方法定义时方法签名中的参数。
实参，就是在调用方法时参入参数中的参数
-
形参：方法定义中的参数
等同于变量定义格式，例如：int ran
-
实参：方法调用中的参数
等同于使用变量或常量，例如： 10, ran
基本类型都是：值传递 byte short int long char 等........
所有对象都是：引用传递
一：值传递
解释:实参传递给形参的是值 形参和实参在内存上是两个独立的变量 对形参做任何修改不会影响实参
列1：
public class Demo {
public static void main(String[] args) {
int ran = 10;
show(ran); //传递的参数则是实参 实际上的参数
}
public static void show(int ran){ //形参 形式上的参数
System.out.println("ran = " + ran);
}
}列2：
public class Demo2 {
public static void main(String[] args) {
int ran = 10;
show(ran);
System.out.println("方法执行后的实参="+ran);
}
public static void show(int ran){
ran = 20;
System.out.println("方法执行时的形参="+ran);
}
}
通俗的讲法就是：形参只是实参创建的一个副本，副本改变了，原本当然不可能跟着改变；
再通俗的讲法就是： 小明去餐厅吃饭，看见别人点的红烧肉挺好吃，九把服务员叫过来，说我要一份红烧肉，服务员从后厨拿来一份红烧肉，小明吃完了，但是他吃的红烧肉跟旁边那个人吃的是一份吗？当然不是。
二：引用传递
实参传递给形参的是参数对于 堆内存上的引用地址 实参和 形参在内存上指向 了同一块区域 对形参的修改会影响实参
public class Demo3 {
public static void main(String[] args) {
int[] arr = {1,2,3};
System.out.println(arr[0]);
System.out.println("-------------");
show(arr);
System.out.println(arr[0]);
}
public static void show(int[] arr){
arr[0] = 100;
System.out.println("show方法里面="+arr[0]);
}
}
由于引用传递，传递的是地址，方法改变的都是同一个地址中的值，
原来arr[0]指向0x1212地址，值是1，
后来在arr[0] 指向的也是0x1212地址，将值变成了100
所以，再查询arr[0]的值的时候，值自然变成了100
通俗点的讲法就是：
小明回到家，他妻子说：冰箱二层有一只鸡，你去做了；
小明做好了，叫妻子过来吃饭。
这个时候，他妻子现在看见的鸡和她买回来的一样吗？
当然不一样，都做熟了；
什么意思呢？
鸡就是数据
冰箱二层就是存储数据的地址
把鸡做熟了就是相当于把值改变了
地方还是那个地方，就是鸡变了。
1203
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
