Java相关知识点Ⅰ

Java面向对象

OOP--object oriented programming

什么是对象？

万物皆为对象   object--对象

什么是类？

从多个对象中抽象出来的共同的特征为类

构造方法

Public class Person{

    Public Person(){}

}

方法名与类名相同

创建对象时，构造方法被调用

不能用关键字void static ，能用return 但不能有返回值

用于成员初始化

构造方法的种类

有参有返

有参无返

无参无返

参分为形参与实参

形参：形式参数，用于占位置

实参：具体的实际的常量

Overload重载

在一个类中，构造方法名相同，参数列表不同

构造方法的重载用于多种途径去创建对象

方法的重载用于不同的参数相同的业务去描述功能

Override重写

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。

This关键字

可用于调用无参构造方法

可作为返回值

用于构造方法初始化对象

Debug

查看代码执行流程的工具

F5 进方法   F6 执行下一行   F8到下一个断点

封装

访问修饰符权限

	同一个类	同一个包	子类	所有类
Private	T
Default	T	T
Protected	T	T	T
Public	T	T	T	T

Private将类的属性私有化，当想给外界提供访问时，需要通过特殊访问途径，通常是get和post方法；

继承

单继承关系

一个子类只能有一个父类，一个父类可以有多个子类；

父类相对子类很抽象

子类对于父类很具体

通过Extends描述子类继承父类

子类可以使用父类的属性和方法，父类不能使用子类独有的属性和方法

创建子类对象时，要先调用父类的构造方法，再调用子类的构造方法

父类，子类代码块的执行顺序：

静态父类代码块  只执行一次 并且在类加载的时候执行

静态子类代码块

父类代码块

父类构造方法

子类代码块

子类构造方法

注意静态的变量的位置，若他在静态代码块之前则先加载；若在静态的变量之后，则按照静态代码块的顺序执行。

如果有静态变量则先加载静态变量，再进主方法，一个类中静态的代码会按照代码的顺序来执行。

Super关键字

超类，基类的引用

不能当返回值使用

转型

引用数据类型的转换

小的类型转大的类型叫向上转型    自动转换

大的类型转小的类型叫向下转型    强制转换

ClasscastException   类型转换异常

Instanceof  关键字  用于判断对象是否属于后面的类型

如果属于  返回true

如果不属于返回false

Animal aa = new Dog("大hong",6);

Animal aaa = new Cat("Bosi",4);

//对象   type ---类型

if (!(aa instanceof Dog))

System.out.println(false);

else{

Dog ddd = (Dog) aa;

}

多态

对象的多种形态

多态的表现形式之一   父类引用指向子类对象

注意：父类引用访问不了子类独有的属性和方法

      父类引用调用的重写的方法会调用相应子类的重写的方法

Static关键字

被static修饰的属性和方法被整个程序共享，通过类名直接调用

静态方法中不能访问非静态变量和方法

在非静态方法中不能声明静态的局部变量

被static修饰的属性优先被加载，优先于主方法

静态代码块值执行一次，优先于代码块和构造方法

静态代码块和静态变量同时存在时，按照先后顺序执行

Java的23种设计模式 Java设计模式：23种设计模式全面解析（超级详细） (biancheng.net)

请大家了解一下

Object

Object--对象  是所有引用数据类型的父类   在 Java.lang中

表示的所有对象

Int [] arr=new int[3];   

栈：存储局部变量      堆：存储new出来的内容（实体，对象）

New 开辟内存空间  

每一个new 出来的东西都会有一个地址值，使用完毕，会被垃圾回收器空闲时回收

0，1，2 为索引

数组初始化时，会为存储空间添加默认值

整数：默认值 0

浮点数：默认值 0.0

布尔值：默认值false

字符:默认值 空字符

引用数据类型：默认值 null

假设数组内存地址为ox01

然后将地址赋予arr

接着 syso(arr);得到的便会是ox01.

==和equals的区别

==比较的是变量内存地址，equals在API中定义的是比较内容，但要重写equals方法。

Equals底层源码

public boolean equals(Object obj) {

        return (this == obj);

}

Equals方法重写

package com.openlab.domain; import static org.hamcrest.CoreMatchers.instanceOf; public class Person { private String name; private int age; public Person(String name,int age) { this.name  = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } //     @Override //    public boolean equals(Object obj) { //     //      if (!(obj instanceof Person)) //      return false; //       Person p = (Person) obj; //       //     return this.getName().equals(p.getName())  && this.getAge() == p.getAge(); //    } }

toString

当打印语句调用的时候默认调用toString方法

来自于object当中的toString

把实体类以字符串的形式输出来

String s = String.valueOf(x);

public static String valueOf (Object obj) {

        return (obj == null) ? "null" : obj.toString();//重写

}

Hashcode

返回对象的哈希码值------主要用来判断是否有重复数据

整数对应hashcode就是整数本身

单个字符的hashcode对应ASCII码

字符串需要通过String的hashcode来进行运算

自定义的实体类可以自定义hashcode方法，通过类的属性来对其运算，可以把它理解成方法区中常量所对应的地址

Final

当final修饰类的时候，该类无法被继承

当final修饰方法的时候，该方法不能被重写

当final修饰变量的时候，该变量为常量，无法被修改

封装类

八大基本数据类型都有所对应的封装类

Byte------byte

Short------short

Integer------int

Long------long

Float------float

Double------double

Boolean------boolean

Character------char

自动装箱，拆箱

Java中基础数据类型与他们的包装类进行运算时，编译器会自动帮我们进行转换，转换过程堆程序员是透明的，这就是装箱和拆箱，装箱和拆箱可以使我们的代码更简洁易懂。

当基本数据类型与封装类进行以下操作时，编译器会自动帮我们进行装箱或拆箱

进行 = 赋值操作（装箱或拆箱）

进行 + - * / 混合运算（拆箱）

进行 >  <  ==  比较运算（拆箱）

调用equals进行比较（装箱）

Arraylist，hashmap等集合类添加基础数据类型时（装箱）

public static Integer valueOf(int i) {

        if (i >= IntegerCache.low && i <= IntegerCache.high)

            return IntegerCache.cache[i + (-IntegerCache.low)];

        return new Integer(i);

    }

Cache 缓存

抽象

抽象类        来自于继承

抽象类------单继承

特点：

抽象方法必须在抽象类中

抽象类和普通类一样都有属性 构造方法 方法

抽象类不能直接实例化，可以通过子类进行实例化

当子类继承抽象类时 抽象方法在子类中必须要存在相应的实现

抽象类可以继承抽象类 ，子类可以不实现父类的抽象方法

子类不再是抽象类时 需要实现父类及其父类的父类中的抽象方法都要实现。

package com.openlab.pojo;

public abstract class Animal {

public String name;

public int age;

public Animal(String name,int legs) {

System.out.println("Animal");

}

public abstract void enjoy();

public void f(){

}

}

接口interface

多继承关系

特点：

接口没有构造器  不能创建对象

接口中的方法都是抽象方法

接口中可以声明常量

通过implements关键字进行实现接口，可以实现多个接口，接口之间用逗号间隔

实现接口后，实现类就是接口的数据类型

使用场景：提供标准

接口可以使用的关键字

Public   default   abstract

接口和抽象类的区别

不同点：

抽象类是单继承   接口多继承

抽象类中有构造器 变量  普通方法   接口只能有常量和抽象方法

关键字不同  抽象类是class  extends 实现继承    

            接口interface   implements 实现接口

相同点：

都有抽象方法

都不能够直接进行实例化对象 而是通过子类和实现类进行实例化

抽象类可以实现接口

接口可以继承接口

接口不能继承抽象类

接口不能实现接口

内部类

当两个类属于嵌套关系时，嵌套的类叫内部类   被嵌套的类叫外部类

Class文件名称：外部类名称$内部类名称

例：Outer$Inner

内部类分类

成员内部类   局部内部类   静态内部类   匿名内部类

为什么java要设计内部类，内部类的存在有什么好处？

内部类加入属性 ----安全性相对较高、设计性更隐秘 节约资源，减少代码的冗余度

成员内部类

和成员变量以及成员方法相同 也是外部类的成员

特点：

成员内部类不可以声明静态的成员内部类变量和内部类静态方法

成员内部类可以访问外部类的成员变量和成员方法

非静态成员方法创建对象直接创建

静态成员方法

先创建外部类对象，通过外部类对象去创建内部类对象 最后用内部类对象访问内部类成员方法。

静态内部类

静态内部类是指使用 static 修饰的内部类。

在创建静态内部类的实例时，不需要创建外部类的实例。

静态内部类中可以定义静态成员和实例成员。

静态内部类可以直接访问外部类的静态成员，如果要访问外部类的实例成员，则需要通过外部类的实例去访问。

局部内部类

类在方法的里面 ---相当于局部变量

调用： 通过外部类方法的调用 去调用内部类的方法

匿名内部类

在结构上等同于方法内部类

  简单来说 内部类没有名字---无法构造

一般情况下匿名内部类 代码行数都不太多，在业务上讲匿名内部类中的方法业务，只使用一次就够了。

写的还不是很全面，还请见谅/(ㄒoㄒ)/~~