Java基础(非常不全面)

最新推荐文章于 2024-08-12 16:47:32 发布

十二被踹飞了

最新推荐文章于 2024-08-12 16:47:32 发布

阅读量819

点赞数 23

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2301_81577980/article/details/136216887

版权

特性:

简单性----面向对象----可移植性-----高性能
分布式----动态性-----多线程-------安全性健壮性

this:
- 代表对象。就是所在函数所属对象的引用。哪个对象调用了this所在的函数，this就代表哪个对象，就是哪个对象的引用.....在定义功能时，如果该功能内部使用到了调用该功能的对象，这时就用this来表示这个对象。
- this 还可以用于构造函数间的调用。调用格式：this(实际参数)；
  - this对象后面跟上 . 调用的是成员属性和成员方法(一般方法)；
  - this对象后面跟上 () 调用的是本类中的对应参数的构造函数
- 用this调用构造函数，必须定义在构造函数的第一行 , 因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败
- This：代表是本类类型的对象引用。
Super
- Super：代表是子类所属的父类中的内存空间引用。
- super(): 表示父类的构造函数，并会调用于参数相对应的父类中的构造函数。而super():是在调用父类中空参数的构造函数。
super()或者this()都是调用构造函数，构造函数用于初始化，初始化的动作要先完成 ,要在第一行

关键字,类,接口:

final:
- 特征：凡是引用final关键字的地方皆不可修改！
- 修饰类：表示该类不能被继承；
- 修饰方法：表示方法不能被重写；
- 修饰变量：表示变量只能一次赋值以后值不能被修改（常量）
- 如果修饰引用,那么表示引用不可变,引用指向的内容可变
- 被final修饰的方法,JVM会尝试将其内联,以提高运行效率
static: 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。
- 静态变量和静态方法.被static所修饰的变量/方法都属于类的静态资源,类实例所共享.
- 也用于静态块,多用于初始化操作:
final与static的区别

关键词       修饰物                       影响

final 	     变量     		分配到常量池中，程序不可改变其值
final        方法 			子类中将不能被重写
final 	      类 			不能被继承
static 	     变量 			分配在内存堆上，引用都会指向这一个地址而不会重新分配内存
static 	     方法块 		    虚拟机优先加载
static 	     类 			可以直接通过类来调用而不需要new

想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
静态修饰的成员，可以直接被类名所调用。表示，静态的成员多了一种调用方式。类名.静态方式
静态随着类的加载而加载。而且优先于对象存在。

—————————————————————————————————————————

关键字:

abstract:

表明类或者成员方法具有抽象属性
implements
- 表明一个类实现了给定的接口
volatile(没用过)
- 表明两个或者多个变量必须同步地发生变化
break
- 提前跳出一个块
continue
- 回到一个块的开始处
instanceof
- 用来测试一个对象是否是指定类型的实例对象

接口：

是用关键字interface定义的。
接口中包含的成员，最常见的有全局常量、抽象方法。
注意：接口中的成员都有固定的修饰符。
- 成员变量：public static final
- 成员方法：public abstract

interface Inter{
public static final int x = 1;
public abstract void show();
}

接口中有抽象方法，说明接口不可以实例化。接口的子类必须实现了接口中所有的抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。
类与类之间存在着继承关系，类与接口中间存在的是实现关系。

继承用extends , 实现用implements ；

接口和类不一样的地方，就是，接口可以被多实现，这就是多继承改良后的结果。java将多继承机制通过多现实来体现。
一个类在继承另一个类的同时，还可以实现多个接口。所以接口的出现避免了单继承的局限性。还可以将类进行功能的扩展。
其实java中是有多继承的。接口与接口之间存在着继承关系，接口可以多继承接口。
接口都用于设计上，设计上的特点:

1：接口是对外提供的规则。

2：接口是功能的扩展。

3：接口的出现降低了耦合性。

抽象类与接口:

抽象类：一般用于描述一个体系单元，将一组共性内容进行抽取，特点：可以在类中定义抽象内容让子类实现，可以定义非抽象内容让子类直接使用。它里面定义的都是一些体系中的基本内容。
接口：一般用于定义对象的扩展功能，是在继承之外还需这个对象具备的一些功能。
抽象类和接口的共性：都是不断向上抽取的结果。

抽象类和接口的区别：

抽象类只能被继承，而且只能单继承。
- 接口需要被实现，而且可以多实现。
抽象类中可以定义非抽象方法，子类可以直接继承使用。
- 接口中都有抽象方法，需要子类去实现。
抽象类使用的是 is a 关系。
- 接口使用的 like a 关系。
抽象类的成员修饰符可以自定义。接口中的成员修饰符是固定的。全都是public的。java支持private类型

内部类:

将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类

成员内部类:

可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员

局部内部类:

是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

匿名内部类:

就是没有名字的类:

静态内部类:

被声明为static的内部类，他可以不依赖内部类而实例，而通常的内部类需要实例化外部类，从而实例化。静态内部类不可以有与外部类有相同的类名。不能访问外部类的普通成员变量，但是可以访问静态成员变量和静态方法（包括私有类型）一个静态内部类去掉static 就是成员内部类，他可以自由的引用外部类的属性和方法，无论是静态还是非静态。但是不可以有静态属性和方法
当内部类定义在外部类中的成员位置上，可以使用一些成员修饰符修饰 private、static。
默认修饰符。
- 直接访问内部类格式：外部类名.内部类名变量名 = 外部类对象.内部类对象;
- Outer.Inner in = new Outer.new Inner();//这种形式很少用。
- 但是这种应用不多见，因为内部类之所以定义在内部就是为了封装。想要获取内部类对象通常都通过外部类的方法来获取。这样可以对内部类对象进行控制。
私有修饰符。
- 通常内部类被封装，都会被私有化，因为封装性不让其他程序直接访问。
静态修饰符。
- 如果内部类被静态修饰，相当于外部类，会出现访问局限性，只能访问外部类中的静态成员。
- 注意；如果内部类中定义了静态成员，那么该内部类必须是静态的。
- 内部类编译后的文件名为：“外部类名$内部类名.java”；
- 内部类可以直接访问外部类的成员是因为内部中持有一个外部类的引用。内部类可以定义在外部类中的成员位置上，也可以定义在外部类中的局部位置上。
- 当内部类被定义在局部位置上，只能访问局部中被final修饰的局部变量。
- 匿名内部类：
  - 没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类：需要前提，内部类必须继承一个类或者实现接口。
- 匿名内部类的格式：new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。
- 匿名内部类的使用场景：
  - 当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。
  - 其实就是在创建匿名内部类时，该类中的封装的方法不要过多，最好两个或者两个以内
- 成员变量和局部变量
  - 成员变量直接定义在类中 , 局部变量定义在方法中，参数上，语句中
  - 成员变量在这个类中有效 , 局部变量只在自己所属的大括号内有效，大括号结束，局部变量失去作用域
  - 成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放。
  - 构造函数：
    - 用于给对象进行初始化，是给与之对应的对象进行初始化，它具有针对性，函数中的一种。
    - 特点：
      - 该函数的名称和所在类的名称相同。
      - 不需要定义返回值类型。
      - 该函数没有具体的返回值。
    - 注:
      - 所有对象创建时，都需要初始化才可以使用。
      - 一个类在定义时，如果没有定义过构造函数，那么该类中会自动生成一个空参数的构造函数 , 为了方便该类创建对象，完成初始化。
      - 如果在类中自定义了构造函数，那么默认的构造函数就没有了。
      - 一个类中，可以有多个构造函数，因为它们的函数名称都相同，所以只能通过参数列表来区分。所以，一个类中如果出现多个构造函数。它们的存在是以重载体现的。
- 构造函数和一般函数
  - 两个函数定义格式不同。
  - 构造函数是在对象创建时，就被调用，用于初始化，而且初始化动作只执行一次。
  - 一般函数，是对象创建后，需要调用才执行，可以被调用多次。
- 构造代码块和构造函数
  - 构造代码块：是给所有的对象进行初始化，也就是说，所有的对象都会调用一个代码块。只要对象一建立。就会调用这个代码块。
  - 构造函数：是给与之对应的对象进行初始化。它具有针对性。

Serializable接口(实现序列化):

将对象的状态信息转换为可以存储或传输的形式的过程作用就是进行传输或者持久化
序列化:
- 用来处理对象流的一种机制,可以保存内存中的java对象状态,同时为了方便初传输
Serializable接口的作用:
- 将一个java对象变成字节流的形式传出去或者从一个字节流中恢复成一个java对象,jre本身就提供了这种支持，我们可以调用 OutputStream 的 writeObject 方法来做.,如果要让java做，要被传输的对象必须实现 serializable 接口，javac编译时就会进行特殊处理,编译的类才可以被 writeObject 方法操作，这就是序列化。需要被序列化的类必须实,Serializable 接口，没有需要实现方法，implements Serializable只是为了标注该对象是可被序列化的。-----(源于网络中的说法)
- 方便传输，速度快，安全，被调用方序列化，调用方反序列化拿到传输前最原始的java对象，常常会用于不同进程之间的对象传输
- 方便存储，存储成文件还是数据库都行，存储为文件，下回要用可以直接反序列拿到对象
怎么序列化和反序列化:
- 实现序列化接口就行（里面什么方法都没有，不用管的，只是一个标记接口而已）Serializable
序列化时需要注意事项:
- 序列化时最好是定义序列化版本id 即 public static final Long seriaVersionUID = 1L (默认) 或者 xxxxx L（自定义64位都行）
- 因为反序列化会判断序列化中的id和类中的id是否一样，如果不定义虽然会自动生成，但如果后面改了东西列，所以还是自觉点定义一个id，省去好多麻烦
- 同时记住静态变量不会被序列化的，它可不在堆内存中，序列化只会序列化堆内存

创建一个对象
- 将首地址赋值给变量，变量就引用了该实体。(指向了该对象)
- 调用该实体对应的构造函数，进行构造函数初始化
- 进行构造代码块初始化。
- 对属性进行显示初始化。
- 进行属性的空间分配，并进行了默认初始化。
- 在堆内存中开辟一个实体空间，分配了一个内存首地址值。new
- 执行main方法时，在栈内存中开辟了main方法的空间，然后在main方法的栈区分配变量。
- 先将硬盘上指定位置的Person.class文件加载进内存。
- Java静态变量和成员变量
  - 有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。
  - 成员变量只能被对象所调用,静态变量可以被对象调用,也可以被类名调用
  - 成员变量所属与对象,所以也称为实例变量.静态变量所属于类,所以也称为类变量.
  - 成员变量与对象共存亡,随着对象创建而存在,随着对象被回收而释放,静态变量与类共存亡,随着类的加载而存在,随着类的消失而消失.
  - 成员变量储存于堆内存中.静态变量存在于方法区中.
  - 成员变量（数据共享时静态化）
  - 该成员变量的数据是否是所有对象都一样：
    - 如果是，那么该变量需要被静态修饰，因为是共享的数据。
    - 如果不是，那么就说这是对象的特有数据，要存储到对象中。
  - 成员函数（方法中没有调用特有数据时就定义成静态）
    - 如果判断成员函数是否需要被静态修饰呢？
    - 只要参考，该函数内是否访问了对象中的特有数据：
      - 如果有访问特有数据，那方法不能被静态修饰。
        
        如果没有访问过特有数据，那么这个方法需要被静态修饰。
  - 静态方法只能访问静态成员，不可以访问非静态成员。
    - 因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
  - 静态方法中不能使用this，super关键字。
    - 因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。
  - 主函数是静态的
  - 成员分两种：
    - 成员变量。（数据共享时静态化）
    - 该成员变量的数据是否是所有对象都一样：
    - 如果是，那么该变量需要被静态修饰，因为是共享的数据。
    - 如果不是，那么就说这是对象的特有数据，要存储到对象中。
  - 成员函数（方法中没有调用特有数据时就定义成静态）
    - 判断成员函数是否需要被静态修饰,只要参考，该函数内是否访问了对象中的特有数据
    - 如果有访问特有数据，那方法不能被静态修饰。
    - 如果没有访问过特有数据，那么这个方法需要被静态修饰。
  - 成员变量和静态变量的区别：
    - 成员变量所属于对象。所以也称为实例变量。
    - 静态变量所属于类。所以也称为类变量。
    - 成员变量存在于堆内存中。
    - 静态变量存在于方法区中。
    - 成员变量随着对象创建而存在。随着对象被回收而消失。
    - 静态变量随着类的加载而存在。随着类的消失而消失。
    - 成员变量只能被对象所调用。
    - 静态变量可以被对象调用，也可以被类名调用。
  - 所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。
  - 静态的注意：静态的生命周期很长。
  - 静态代码块：就是一个有静态关键字标示的一个代码块区域。定义在类中。
  - 作用：可以完成类的初始化。静态代码块随着类的加载而执行，而且只执行一次（new 多个对象就只执行一次）。如果和主函数在同一类中，优先于主函数执行。

修饰符:

Public：访问权限最大。
static：不需要对象，直接类名即可。
void：主函数没有返回值。
Main：主函数特定的名称。
(String[] args)：主函数的参数，是一个字符串数组类型的参数，jvm调用main方法时，传递的实际参数是 new String[0]。
jvm默认传递的是长度为0的字符串数组，我们在运行该类时，也可以指定具体的参数进行传递。可以在控制台，运行该类时，在后面加入参数。参数之间通过空格隔开。jvm会自动将这些字符串参数作为args数组中的元素，进行存储。
静态代码块、构造代码块、构造函数同时存在时的执行顺序：
- 静态代码块 ———> 构造代码块 ———> 构造函数；
类中的成员特点:
- 成员变量。
  - 当子父类中出现一样的属性时，子类类型的对象，调用该属性，值是子类的属性值
  - 如果想要调用父类中的属性值，需要使用一个关键字：super
- 注意：子父类中通常是不会出现同名成员变量的，因为父类中只要定义了，子类就不用在定义了，直接继承过来用就可以了。
- 成员函数
  - 当子父类中出现了一模一样的方法时，建立子类对象会运行子类中的方法。好像父类中的方法被覆盖掉一样。所以这种情况，是函数的另一个特性：覆盖(复写，重写)
  - 当一个类的功能内容需要修改时，可以通过覆盖来实现
- 构造函数
  - 发现子类构造函数运行时，先运行了父类的构造函数 , 子类的所有构造函数中的第一行，其实都有一条隐身的语句super();

子类的实例化过程:

因为子类继承父类，会继承到父类中的数据，必须要看父类是如何对自己的数据进行初始化的。
所以子类在进行对象初始化时，先调用父类的构造函数，这就是子类的实例化过程。
注意：
- 子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();
- 如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。
- 如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。

super()或者this():为什么一定要定义在第一行？

因为。

继承：

当类与类之间存在着所属关系时，才具备了继承的前提。a是b中的一种。a继承b。狼是犬科中的一种。
英文书中，所属关系：" is a "
注意：不要仅仅为了获取其他类中的已有成员进行继承。
所以判断所属关系，可以简单看，如果继承后，被继承的类中的功能，都可以被该子类所具备，那么继承成立。如果不是，不可以继承。
在方法覆盖时，注意两点：
- 子类覆盖父类时，必须要保证，子类方法的权限必须大于等于父类方法权限可以实现继承。否则，编译失败。
- 覆盖时，要么都静态，要么都不静态。 (静态只能覆盖静态，或者被静态覆盖)
弊端：
- 打破了封装性。对于一些类，或者类中功能，是需要被继承，或者复写的。可以用final:最终解决 , 其实这样的原因的就是给一些固定的数据起个阅读性较强的名称。
- 不加final修饰那么这个值是一个变量，是可以更改的。加了final，程序更为严谨。常量名称定义时，有规范，所有字母都大写，如果由多个单词组成，中间用 _ 连接。

抽象类: abstract

抽象：不具体，看不明白。抽象类表象体现。
在不断抽取过程中，将共性内容中的方法声明抽取，但是方法不一样，没有抽取，这时抽取到的方法，并不具体，需要被指定关键字abstract所标示，声明为抽象方法。
抽象方法所在类一定要标示为抽象类，也就是说该类需要被abstract关键字所修饰。

抽象类的特点：

抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。
抽象方法只定义方法声明，并不定义方法实现。
抽象类不可以被创建对象(实例化)。
只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

抽象类的细节：

抽象类中有构造函数
- 用于给子类对象进行初始化。
抽象类中可以定义非抽象方法
- 可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。
抽象关键字abstract和哪些不可以共存？final , private , static
抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。

多态:

多态是继封装、继承之后，面向对象的第三大特性。
多态现实意义理解：
- 现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。
Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。
多态体现为父类引用变量可以指向子类对象。
前提条件：必须有子父类关系。
在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。
多态的定义与使用格式定义格式：父类类型变量名=new 子类类型();

泛型:

泛型是Java SE 1.5之后的特性，意味着编写的代码可以被不同类型的对象所重用
不必因为添加元素类型的不同而定义不同类型的集合

重写与重载:

重写：

发生在父类与子类之间
方法名，参数列表，返回类型（除过子类中方法的返回类型是父类中返回类型的子类）必须相同
访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private)
重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常

重载:

重载Overload是一个类中多态性的一种表现
重载要求同名方法的参数列表不同(参数类型，参数个数甚至是参数顺序)
重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准

异常:

三种异常:

被检查的异常(CheckedException)

Exception类本身，以及Exception的子类中除了"运行时异常"之外的其它子类都属于被检查异常。
Java编译器会检查它。此类异常，要么通过throws进行声明抛出，要么通过try-catch进行捕获处理，否则不能通过编译

运行时异常 (RuntimeException)

RuntimeException及其子类都被称为运行时异常。
特点：Java编译器不会检查它。也就是说，当程序中可能出现这类异常时，倘若既"没有通过throws声明抛出它"，也"没有用try-catch语句捕获它"，还是会编译通过

错误(Error)

Error类及其子类。
特点 : 和运行时异常一样，编译器也不会对错误进行检查

一般异常与运行时异常:

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

error和exception :

error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。exception表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况

synchronized线程、同步:

synchronized 关键字可以应用于方法或语句块，并为一次只应由一个线程执行的关键代码段提供保护。
synchronized 关键字可防止代码的关键代码段一次被多个线程执行。
如果应用于静态方法，那么，当该方法一次由一个线程执行时，整个类将被锁定。
如果应用于实例方法，那么，当该方法一次由一个线程访问时，该实例将被锁定。
如果应用于对象或数组，当关联的代码块一次由一个线程执行时，对象或数组将被锁定。

——————————————————————————————————————————

java分了5片内存区

寄存器。2：本地方法区。3：方法区。4：栈。5：堆。
- 栈：存储的都是局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量 )；只要数据运算完成所在的区域结束，该数据就会被释放。
- 堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。
  - 每一个实体都有内存首地址值。
  - 堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。

注: 不是全面连贯的知识点,部分内容为之前在网络中查看记录的.....后期会自己更新知识点 ....持续更新

十二被踹飞了

关注

23
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
Java基础(非常不全面)

表明类或者成员方法具有抽象属性implements表明一个类实现了给定的接口volatile(没用过)表明两个或者多个变量必须同步地发生变化break提前跳出一个块continue回到一个块的开始处instanceof用来测试一个对象是否是指定类型的实例对象抽象：不具体，看不明白。抽象类表象体现。在不断抽取过程中，将共性内容中的方法声明抽取，但是方法不一样，没有抽取，这时抽取到的方法，并不具体，需要被指定关键字abstract所标示，声明为抽象方法。
复制链接

扫一扫