java基础6（黑马）

一、static

1.static修饰成员变量

static：叫静态，可以修饰成员变量、成员方法。

成员变量按照有无static，分两种。

类变量：有static修饰，属于类，在计算机中只有一份，会被类的全部对象共享。静态成员变量。

实例变量（对象的变量）：无static修饰，属于每个对象。

访问：

类名.类变量（推荐）

对象.类变量（不推荐）

类变量直接放在堆内存中。

类变量：属于类，与类一起加载一次，在堆内存中只有一份，可以被类和类的所有对象共享。

实例变量：属于对象，每个对象都有一份，只能用对象访问。

类变量的应用场景：

在开发中，如果某个数据只需要一份，且希望能够被共享（访问、修改），则该数据可以定义类变量来记住。

2.static修饰成员方法

成员方法的分类：

类方法：有static修饰的成员方法，属于类：

成员方法：无static修饰的成员方法，属于对象。

Student类：

package cn.ensource.d2_staticmethod; public class Student {    double score;    // 类方法    public static void printHelloWorld() {        System.out.println("Hello World");        System.out.println("Hello World");    }     // 实例方法    public void printPass() {        System.out.println("成绩：" + (score >= 60 ? "及格" : "不及格"));    }

Test测试类：

package cn.ensource.d2_staticmethod; public class Test {    public static void main(String[] args) {        // 目标：掌握有无static修饰方法的用法        // 1. 类方法的用法        // 类名.类方法        Student.printHelloWorld();         // 对象.类方法（不推荐）        Student st = new Student();        st.printHelloWorld();         st.score = 80;        st.printPass(); //        Student.printPass();  // 报错    }}

实例方法是不允许使用类名调用。

类方法可以使用类名调；也可以使用实例调，但是不推荐。

static修饰成员方法的应用场景：类方法最常见的应用场景是做工具类。

工具类是什么？

工具类中的方法都是一些类方法，每个方法都是用来完成一个功能的，工具类是给开发人员共同使用的。

3.Static的注意事项

使用类方法和实例方法时的几点注意事项：

类方法中可以直接访问类成员，不可以直接访问实例成员；

实例方法中即可以直接访问类成员，也可以直接访问实例成员（变量和方法）；

实例方法中可以出现this关键字，类方法中不可以出现this关键字。

package cn.ensource._d4_static_attention;public class Student {    static String schoolName; // 类变量    double score;    public static void printHelloWorld1() {        Student.schoolName = "黑马";        Student.printHelloWorld2();         // 类方法中不能访问实例变量、实例方法         
         //System.out.println(score);
          //printPass();          //System.out.println(this);    }     public static void printHelloWorld2() {        System.out.println("Hello World");        System.out.println("Hello World");    }     // 实例方法    public void printPass() {        Student.schoolName = "黑马";        printHelloWorld2();         System.out.println(score);        printPass2();         System.out.println(this);  //那取对象    }     public void printPass2() {     }}

只要记住：类方法只能只能访问类成员。

二、Static应用知识

1.代码块

代码块是类的五大成员之一（成员变量、构造器、方法、代码块、内部类）。

Java类生命周期：加载、验证、准备、初始化、卸载。

代码块分为两种：

静态代码块：

格式：static {}

特点：类加载时自动执行，由于类只会加载一次，所以静态代码也只会执行一次。

作用：完成类的初始化，例如：类变量的初始化赋值。

实例代码块：

格式：{}

特点：每次创建对象的时候，，执行实例代码块，并在构造器前执行。

作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例变量进行初始化赋值的。

2.单例设计模式

设计模式：

架构师会使用到设计模式，开发框架，就需要掌握很多设计模式。

在Java基础阶段学习设计模式，将来面试笔试的时候，笔试题目会经常靠到设计模式。

将来会用到设计模式。框架代码中会用到设计模式。

什么是设计模式？（design pattern）

一个问题经常会有n种解法，其中肯定有一种解法是最优的，这种优的解法被人总结出来了，称之为设计模式。

设计模式就是具体问题的最优解决方法。

设计模式有20多种，对应20多种软件开发中会遇到的问题。

单例设计模式：确保一个类只有一个对象。

写法：

1）把类的构造器私有；

2）定义一个类变量记住类的一个对象；

3）定义一个类方法，返回对象。

三、继承

1.概念

继承：Java中提供了一个关键字extends，用这个关键字，可以让一个类和另外一个类建立父子关系。

继承的特点:

子类能继承父类的非私有成员（成员变量、成员方法）。

父类的私有成员，子类是不能继承的。而父类的非私有成员，子类是能继承的。

私有：private

继承后对象的创建：子类的对象是由子类和父类共同完成的。

继承的执行原理：

私有的变量是不能直接访问的，只能通过getter/setter方法进行访问。

k是私有变量，只能自己访问，k通过B的方法去访问并对外开放。

2.权限修饰符

权限修饰符：就是用来限制类中的成员（成员变量、成员方法、构造器、代码块....）能够被访问的范围。

public是公开完全暴露的意思。

protected：在任意包下的子类里。

我们用到的最多的是private和public。

3.单继承、Object类、方法重写

Java 是单继承的，Java中的类不支持多继承，但是支持多层继承。

Object类是所有类的父类。

Object类：Object类是java所有类的祖宗类，我们写的任意一个类，其实都是Object类的子类或子孙类。

方法重写：

当子类觉得父类中的某个方法不好用，或者无法满足自己的需求的时候，子类可以重写一个方法名称、参数列表一样的方法，去覆盖父类的这个方法，这个就称为方法重写。

注意：重写后，方法的方法，Java会遵循就近原则。

方法重写的概念：

子类写了一个方法名称，形参列表与父类某个方法一样的方法，去覆盖父类的该方法。

申明不变，重新实现。

Override的注解：

用来检测当前的方法，是否是重写的方法，起到校验的作用。

方法重写的注意事项：

私有方法不能被重写（父类私有成员子类是不能继承的）

子类方法访问权限不能更低（public->默认->私有）

子类中访问其他成员遵循就近原则

如果指定访问某个成员变量：

局部变量跟成员变量冲突的时候，我们可以使用shis。this代表的是当前对象。

如果要找父类的成员变量，我们就使用super。super代表父类。

4.子类构造器

子类构造器的特点：子类的全部构造器，都会先调用父类的构造器，再执行自己。

子类会继承父类的数据，可能还会使用父类的数据。所以，子类初始化之前，一定先要完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认就是super();

package cn.ensource.d14_extends_constructor; class F{    public F() {        System.out.println("F类构造器执行了！");    }} class Z extends F{    public Z() {        super();        System.out.println("Z类无参构造器执行了！");    }     public Z(String name) {        super();        System.out.println("Z类有参构造器执行了！");    }}  public class Test {    public static void main(String[] args) {        // 目标：先认识子类构造器的特点，再掌握子类构造器的应用场景        Z z1 = new Z();        Z z2 = new Z("播妞");    }}

执行结果：

可见，不管是子类有参构造器，还是子类无参构造器，都是先调用父类构造器，然后再执行子类构造器。

其实，在子类构造器中，默认会有一个super()存在，不管你调用，还是不调用，都调用这个方法。

super：代表父类存储空间的标识。可以理解为父类对象的引用。

子类构造器可以通过调用父类构造器，把对象中包含父类这部分的数据先进行初始化赋值，再回来把对象里包含子类这部分的数据也进行初始化赋值。

然后t.getter方法，都是到子类和父类中调用相应的的getter方法。

补充知识：

this（...）调用兄弟构造器。

在任意类的构造器中，都可以通过this(...)去调用该类的其他构造器。

5.多态和final、常量

多态是在继承/实现情况下一种现象，表现为：对象多态和行为多态。

同一个对象，在不同时刻表现出来的不同形态。

多态的前提：

要有继承/实现关系

要有方法的重写

要有父类引用指向子类对象。

多态的一个注意事项：

多态对对象、行为的多态，Java中的属性（成员变量）不谈多态。

多态中成员访问特点（记忆）：

成员访问特点：

成员变量：编译看父类，运行看父类；

成员方方法：编译看父类，运行看子类；

多态中的成员转型：

向上转型：

父类引用指向子类对象就是向上转型。

向下转型：

格式：子类对象名 = （子类型）父类引用。

final关键字：final是最终的意思。可以修饰类、方法、变量。

修饰类：该类就被称为最终类，特点是不能被继承了。

修饰方法：该方法是最终方法，特点是不能被重写了。

修饰变量：该变量只能被赋值一次。

常量：使用了static final修饰的成员变量就称为常量。

作用：通常用于记录系统的常量信息。

注意：常量建议名称全部大写，多个单词下划线连接。

6.抽象类和接口概述

抽象类：

当我们在做子类共性功能抽取的时候，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了。在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类就定义为抽象类。

在Java中有一个abstract，它是抽象的意思，可以用它修饰类、成员方法。

package cn.ensource.d4_abstract; // 抽象类public abstract class A {    // 抽象方法，必须用abstract修饰，并且只有方法签名，不能有方法体    public abstract void run();}

认识接口：Java提供了一个关键字Interface，用这个关键字我们可以定义一个特殊的结构：接口。

注意：接口不能创建对象，接口是用来被类实现（implements）的，实现接口的类称为实现类。

一个类可以实现多个接口（接口可以理解为干爹），实现类实现多个接口，必须重写全部接口的全部抽象方法，否则实现类需要定义成抽象类

7.内部类和

1、内部类：

是类中五大成分之一（成员变量、方法、构造函数、内部类、代码块），如果一个类定义在另一个类的内部，这个类就是内部类。

场景：当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。

内部类的四种形式：

成员内部类：了解

静态内部类：了解

局部内部类：了解

匿名内部类：重点

匿名内部类：（重点）

就是一种特殊的局部内部类；所谓匿名：指的是程序员不需要为这个类声明名字。

匿名内部类：（重点）

就是一种特殊的局部内部类；所谓匿名：指的是程序员不需要为这个类声明名字。

package d3_inner_class3; public class Test {    public static void main(String[] args) {        // 目标：掌握匿名内部类，并掌握其作用        Animal a = new Cat();   // 创建子类对象        a.cry();     }} class Cat extends Animal {     @Override    public void cry() {        System.out.println("喵喵~");    }} abstract class Animal {    public abstract void cry();}