java学习 java -，

java学习 java -，

一、继承
继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。[1] Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。比如可以先定义一个类叫车，车有以下属性：车体大小，颜色，方向盘，轮胎，而又由车这个类派生出轿车和卡车两个类，为轿车添加一个小后备箱，而为卡车添加一个大货箱。

继承
特点：
1.减少重复的代码
2.减少你的工作量
3.可以把类中相同的代码 抽取出来 写成一个父类
继承：连接了类与类之间的关系（父子的关系）

继承弊端：
高内聚 低耦合
有时再付类中添加属性 希望子类去继承
但特殊情况 不想子类去继承
继承不继承 要具体问题具体分析

什么时候使用继承？ 符合继承逻辑
例
项目经理 姓名 工资 工号 分红
程序员 姓名 工资 工号

员工类 姓名 工资 工号
项目经理 姓名 工资 工号 （分红）
程序员 姓名 工资 工号
继承父类的什么东西
继承了父类的属性 和 方法（不太准确）

继承时 使用关键字 extends

public static void main(String[] args) {
    Cat cat = new Cat();
    cat.color = "黑猫";
    cat.leg = 4;
}
}
//  类里面不能定义类
class Animal{
    int leg;
    String color;
public void sayHi() {
    System.out.println(leg + "---" + color);
}
}
class Cat extends Animal{

}
class Dog extends Animal{

}

这样 Cat 和 Dog 就继承了 Animal中的属性及方法

java中的继承
1.java中 只允许 单继承 不允许多继承
2.java中 允许 多层继承(属性和方法 回传递继承)

如果我想得到类中 共有的方法和属性 使用哪个类？ 使用继承链最顶端的类
如果我想得到类中 特有的方法和属性 使用哪个类? 使用继承链最末端的类

如果一个类没有写继承哪个类 实际上是继承的系统的 Object类
Object类 是java中 最顶端的类（基类）

public class Demo03 {
public static void main(String[] args) {
    DemoC demoC = new DemoC();
    demoC.name = "我是C";
    demoC.sayHi();
}
}
//  多层继承（爷爷类  父类  子类  孙子类  重孙子类）
//  需求：DemoC 继承 DemoB 继承 DemoA

class DemoA extends Object{
    String name;

public void sayHi() {
    System.out.println(name);
}
}
class DemoB extends DemoA{

}
class DemoC extends DemoB{
String gender;
}

这样 DemoC 就继承 DemoB， DemoB就继承 DemoA

那么 这里会有一个问题 构造方法 可以被继承吗？

public class Demo04 {
public static void main(String[] args) {
    Son son = new Son();
    son.sayHi();

    Son son2 = new Son("zhangsan")  ;
    son.sayHi();
}
}

class Father{
    String name;

public Father() {
    System.out.println("我是爸爸的  无参的构造方法");
}
public Father(String name) {
    System.out.println("我是爸爸的  有参的构造方法");
}

public void sayHi() {
    System.out.println(name);
}
}

class Son extends Father{
public Son() {
    super();//  调用父类无参构造方法
    System.out.println("我是儿子 的无参构造方法");
}
public Son(String name) {
    //  不管你有参无参的构造方法
    //  只要你没有调用父类构造方法  系统都帮你调用
    //  保证继承完整性
    super();
    System.out.println("我是儿子 的有参构造方法");
}
}

super();是调用父类无参构造方法，在子类中没有调用构造方法的时候 ，系统会帮你默认将 super();加上调用父类的无参构造方法，并且不管你 有没有构造方法 构造方法有没有参数，都会给你默认调用，保证继承的完整性

继承时 子类和父类有相同名字的 成员变量

this 和 super 区别
1.this 在类中代表的是 本类的对象（当前类的对象）
2.super 在类中代表的是 父类的对象

this.属性 可以调用到 当前类的属性（现在当前类照这个属性 没找到的话 回去父类里找）遵 循了就近原则
super.属性 可以调用到 父 类的属性

this(); 调用本类的构造方法
super(); 调用父类的构造方法

例

public class Demo05 {
public static void main(String[] args) {
    Apple apple = new Apple();
    apple.print();
}
}
// 水果类
class Fruit{
int num1 = 10;
int num2 = 20;
}

class Apple extends Fruit{
int num2 = 30;

public void print() {
    System.out.println(this.num1);
    System.out.println(this.num2);
    System.out.println(super.num2);
}
}

打印结果

这样更能直观的了解 this 与 super的区别

两个类继承关系
子类 没有 无参构造方法 （有 有参构造方法）
子类的构造方法如何去写？ 可以指定调用有参构造方法 （面试可能会问 在实际开发中不会出现这样的问题）

public class Demo06 {
public static void main(String[] args) {
    Audi a = new Audi("r8");
    a.sayHi();
    System.out.println("--------------");

    Audi b = new Audi();
    b.sayHi();
}
}
class Car{
String name;

//  public Car() {
//      System.out.println("我是Car类的无参构造方法");
//  }
//  
public Car(String name) {
    this.name = name;
    System.out.println("我是Car类的有参构造方法");
}
}

class Audi extends Car{

//  这时  系统将不再给你指定调用默认的无参构造方法
public Audi() {
    super("A8");
    System.out.println("我是Audi类的无参构造方法");
}

public Audi(String name) {
    //  你不写调用父类构造  默认系统给你调用无参构造
    //  你可以指定一个构造方法去调用
    super(name);//  调用了父类  有参的构造方法
    System.out.println("我是Audi类的有参构造方法");
}

public void sayHi() {
    System.out.println(name);
}
}

总体来说 在子类写一个有参的构造方法 只要你在构造方法的里面 调用构造方法并赋值 这时 系统将不再给你指定调用默认的无参构造方法 因为你不写 父类构造 系统默认给你调用无参构造 你可以指定一个构造方法去调用 指定一个有参的构造方法

函数的重写

特点 子类和父类的成员方法一致相同 就是方法的重写
重写的应用场景 当子类的方法 相对于父类的方法有了升级

就是相当于 在原有的父类中有一些功能 现在要添加一些功能 我们就需要函数的重写 从子类中把新的功能添加进去

私有属性 是不能被继承的 （这样说法不是太准确）
因为在实际的继承当中 我们会在类中添加 构造方法 set/get方法 还有成员方法，这些方法我们是可以在子类中继承的，并且可以利用方法 修改并获取这些之前定义的私有属性，所以说这样的说法不太准确

final 关键字
1.修饰类 —— 不能被继承
2.修饰变量 —— 不能被修改
3.修饰方法 —— 不能被重写
命名规则 名字全部大写 多单词用下划线分开

二、代码块
代码块
1.局部代码块
位置：方法中
作用：限定了局部变量的生命周期（作用域问题）
2.构造代码块
位置：在类中 方法外
调用顺序：在你创建对象的时候，如果你有构造代码块
系统会帮你先调用构造代码块 在调用构造方法
作用：如果每个对象都有相同方法要去执行 ，可以再构造代码块中调用（开发中几乎没有这样的场景）

3.静态代码块（使用static来修饰）
位置：再类中 方法外
特点：之加载一次 并且随着类的加载而加载
应用场景：加载驱动（JDBC数据库的连接）

4.同步代码块（多线程）

public class Demo01 {
static {
    System.out.println("我是Demo01 的静态代码块");
}

public static void main(String[] args) {

    //  局部代码块
    {
        int num = 10;
        System.out.println(num);
    }
    Person person = new Person();
    person.sayHi();

    Person person2 = new Person("wangwu",18);
    person2.sayHi();        
}

}

class Person{
    String name;
    int age;

public Person() {
    System.out.println("我是无参的构造方法");
}

public Person(String name, int age) {
    this.name = name;
    this.age = age;

    System.out.println("我是有参的构造方法");
}
public void sayHi() {
    System.out.println(name + "---" + age);
}

public void cYF() {
    System.out.println("穿衣服");
}
//  构造代码块
{
    this.cYF();
    System.out.println("我是构造代码块");
}

//  静态代码块
static {
    System.out.println("我是静态代码块");
}

}

这就是所有代码块的一个执行顺序 现在有main函数的类中寻找 静态代码块 然后输出main函数中的局部代码块 然后是执行调用类中对象的静态代码块 最后是构造方法代码块