Java基础知识点

1、构造器的作用
 1）创建对象，凡是必须和new 一起使用

 2）完成对象的初始化操作

构造器:如果我们没有显示提供构造器,则编译器在编译时创建一个缺省的构造器.
但是,如果我们显示定义了一个构造器,则编译器不再创建默认构造器.
------------------------------->推论:某一个类,至少存在一个构造器.

------------------------------------------------------------
static修饰符表示静态的，可修饰字段、方法、内部类，其修饰的成员属于类,也就是说static修饰的资源属于类级别,而不是对象级别。

static的真正作用：用来区别字段，方法，内部类，初始化代码块是属于对象还是属于类本身。

static修饰符的特点:
       1):static修饰的成员(字段/方法),随着所在类的加载而加载.
                当JVM把字节码加载进JVM的时候,static修饰的成员已经在内存中存在了.
       2):优先于对象的存在.
               对象是我们手动通过new关键字创建出来的.
       3:satic修饰的成员被该类型的所有对象所共享.
                根据该类创建出来的任何对象,都可以访问static成员.(狗天生就吃屎.)
                剧透:表面上通过对象去访问static成员,其本质依然使用类名访问,和对象没有任何关系(通过反编译看到的).
       4):直接使用类名访问static成员

             因为static修饰的成员直接属于类,不属于对象,所以可以直接使用类名访问static成员.

类成员和实例成员的访问 :
类中的成员:字段,方法,内部类.
类成员:      使用static修饰的成员.
实例成员:  没有使用static修饰的成员.
----------------------------------------------------------------------------
类成员只能访问类成员,实例成员只能访问实例成员.
----------------------------------------------------------------------------
类成员,直接属于类, 可以通过类来访问static字段和static方法.
实例成员,只属于对象, 通过对象来访问非static字段和非static方法.
                    (对象其实可以访问类成员,但是底层依然使用类名访问的.)
---------------------------------------------------------------------------------------------
在static方法中,只能调用static成员.

非static方法,可以访问静态成员,也可以访问实例成员.

注意:

是在Java中切记：static是不允许用来修饰局部变量。

访问权限控制：
private:         表示私有的, 表示类访问权限.  只能在本类中访问,离开本类之后,就不能直接访问.
不写(缺省):  表示包私有,表示包访问权限.  访问者的包必须和当前定义类的包相同才能访问.
protected:    表示子类访问权限,同包中的可以访问,即使不同包,但是有继承关系,也可以访问.

public:           表示全局的,可以公共访问权限,如某个字段/方法,使用了public修饰,则可以在当前项目中任何地方访问.

this　关键字

什么是this:
      表示当前对象,什么优势当前对象.
       this主要存在于两个位置:
              构造器中:  就表示当前创建的对象.
              方法中:  哪一个对象调用this所在的方法,那么此时this就表示哪一个对象.

当一个对象创建之后,JVM会分配一个引用自身的引用:this.

继承
public class 子类类名 extends 父类类名{
编写自己特有的状态和行为
}
在Java中,类和类之间的继承关系只允许单继承,不允许多继承。
继承关系的作用:
    1):解决了代码的重复问题.
    2):真正的作用,表示出一个体系.


子类继承父类之后,可以拥有父类的某一些状态和行为(子类复用了父类的功能或状态).
子类到底继承了父类的哪些成员(根据访问修饰符来判断):
      1):如果父类中的成员使用public修饰,子类继承.
      2):如果父类中的成员使用protected修饰,子类也继承,即使父类和子类不在同一个包中.
      3):如果父类和子类在同一个包中,此时子类可有继承父类中 缺省修饰符的成员.
      4):如果父类中的成员使用private修饰,子类打死都继承不到.因为private只能在本类中访问.
      5):父类的构造器,子类也不能继承,因为构造器必须和当前的类名相同.


请注意:不要去背文字,立马写代码去证明.






方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。


(1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
(2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。

(3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现

多态

所谓多态: 对象具有多种形态,对象可以存在不同的形式.
Animal    a   = null;
          a   =  new    Dog();   //a此时表示Dog类型的形态
          a   =  new    Cat();    //a此时表示Cat类型的形态


多态的特点:
            把子类对象赋给父类变量,在运行时期会表现出具体的子类特征(调用子类的方法).
             Animal a = new Dog();
 
多态时方法调用问题:
  前提:必须先存在多态情况:
  存在父类:SuperClass,子类:SubClass,方法:doWork.

多态存在的三个必要条件
1、继承
2、重写
3、父类引用指向子类对象

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}
执行以上程序，输出结果为：

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

多态的实现方式

方式一：重写：

这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)。

方式二：接口

• 1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。

• 2. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。

方式三：抽象类和抽象方法

instanceof  运算符: 判断该对象是否是某一个类的实例.
语法格式：boolean b = 对象A   instanceof  类B;  // 判断 A对象是否是 B类的实例,如果是,返回true.

代码块

基本类型和包装类

final 修饰符

（1）final 修饰的类，表示最终的类，该类不能再有子类。
（2）final 修饰的方法，最终的方法，该方法不能被子类覆盖
子类可以调用，但是不能覆盖
（3）final 修饰的变量  最终的变量、常量、该变量只能赋值一次，不能再赋值

final 是唯一可以修饰局部变量的修饰符。

接口和抽象类

相同点：
1):都位于继承的顶端，用于被其他实现或继承。
2):都不能实例化。
3):都可以定义抽象方法，其子类/实现类都必须覆写这些抽象方法。  
不同点：
1):接口没有构造方法，抽象类有构造方法。
2):抽象类可包含普通方法和抽象方法，接口只能包含抽象方法(Java8之前);
3):一个类只能继承一个直接父类(可能是抽象类)，接口是多继承的并且只支持一个类实现多个接口(接口弥补了Java的单继承)。
4):成员变量：接口里默认是public static final，抽象类是默认包权限。
5):方法：接口里默认是public abstract，抽象类默认是默认包访问权限。
6):内部类：接口里默认是public static，抽象类默认是默认包访问权限。

抽象类和接口的对比

参数	抽象类	接口
默认的方法实现	它可以有默认的方法实现	接口完全是抽象的。它根本不存在方法的实现
实现	子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。	子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
构造器	抽象类可以有构造器	接口不能有构造器
与正常Java类的区别	除了你不能实例化抽象类之外，它和普通Java类没有任何区别	接口是完全不同的类型
访问修饰符	抽象方法可以有public、protected和default这些修饰符	接口方法默认修饰符是public。你不可以使用其它修饰符。
main方法	抽象方法可以有main方法并且我们可以运行它	接口没有main方法，因此我们不能运行它。
多继承	抽象方法可以继承一个类和实现多个接口	接口只可以继承一个或多个其它接口
速度	它比接口速度要快	接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。
添加新方法	如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。	如果你往接口中添加方法，那么你必须改变实现该接口的类。

什么时候使用抽象类和接口

• 如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。
• 如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。
• 如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类