Java基础入门概念

为什么选择Java？

每个人心中都有一个初恋，对没错，java就是我的初恋，没有为什么。

对象

世间万物都是对象，我们自身也是对象，不同对象之间的相互作用和通讯构成了完整的现实世界。

类

面向对象就是把事物分类的过程。

变量

JAVA中变量包括成员变量，局部变量，静态变量。例如

public class A{
? ? String a; // a 就是成员变量
? ? static String c; // c 就是静态变量
? ? public void getA() {
? ? ? ? String b = ""; // b 就是局部变量
? ? }
}

方法

方法包括：方法名、返回值、参数和方法体组成
例如：

public String getA() {
? ? return “a”;
}

String是返回值类型，“a”是返回值，getA是方法名，()中是空的代表，此方法为无参方法。

构造函数

构造函数必须与类同名，每个类可以有一个以上构造器，构造函数没有返回值构造函数可以有0个或0个以上的参数，构造器总是伴随new操作一起调用
例如：

public class A{
? ? public A() {}
? ??
? ? public A(int v1) {}
? ??
? ? public A(int v1, int v2) {}
}

对象引用 A a = new A();

this关键字

在类里面来引用这个类的属性和方法。内部类可以用类名.this的方式引用外部对象

封装

首先是抽象，把事物抽象成一个类，其次才是封装，将事物拥有的属性和动作隐藏起来，只保留特定的方法与外界联系

继承

Java的类可以分为三类：

类：使用class定义，没有抽象方法

• 抽象类：使用abstract class定义，可以有也可以没有抽象方法
• 接口：使用inerface定义，只能有抽象方法

在这三个类型之间存在如下关系：

• 类可以extends：类、抽象类（必须实现所有抽象方法），但只能extends一个，可以implements多个接口（必须实现所有接口方法）
• 抽象类可以extends：类，抽象类（可全部、部分、或者完全不实现父类抽象方法），可以implements多个接口（可全部、部分、或者完全不实现接口方法）
• 接口只能extends一个接口

继承以后子类可以得到什么：

• 子类拥有父类非private的属性和方法
• 子类可以添加自己的方法和属性，即对父类进行扩展
• 子类可以重新定义父类的方法，即多态里面的覆盖，后面会详述

关于构造函数：

• 构造函数不能被继承，子类可以通过super()显示调用父类的构造函数
• 创建子类时，编译器会自动调用父类的 无参构造函数
• 如果父类没有定义无参构造函数，子类必须在构造函数的第一行代码使用super()显示调用
• 类默认拥有无参构造函数，如果定义了其他有参构造函数，则无参函数失效，所以父类没有定义无参构造函数，不是指父类没有写无参构造函数。看下面的例子，父类为Human，子类为Programmer。

多态
在了解多态之前，首先需要知道方法的唯一性标识即什么是相同/不同的方法，一个方法可以由：修饰符如public、static+返回值+方法名+参数+throw的异常 5部分构成，其中只有方法名和参数是唯一性标识，意即只要方法名和参数相同那他们就是相同的方法，所谓参数相同，是指参数的个数，类型，顺序一致，其中任何一项不同都是不同的方法。何谓重载，重载是指一个类里面（包括父类的方法）存在方法名相同，但是参数不一样的方法，参数不一样可以是不同的参数个数、类型或顺序，如果仅仅是修饰符、返回值、throw的异常 不同，那这是2个相同的方法，编译都通不过，更不要说重载了

重写

何谓覆盖/重写，覆盖描述存在继承关系时子类的一种行为子类中存在和父类相同的方法即为覆盖，何谓相同方法请牢记前面的描述，方法名和参数相同，包括参数个数、类型、顺序

覆盖/重写的规则：子类不能覆盖父类private的方法，private对子类不可见，如果子类定义了一个和父类private方法相同的方法，实为新增方法；重写方法的修饰符一定要大于被重写方法的修饰符(public > protected > default > private)，重写抛出的异常需与父类相同或是父类异常的子类，或者重写方法干脆不写throws，重写方法的返回值必须与被重写方法一致，否则编译报错，静态方法不能被重写为非静态方法，否则编译出错

理解了上述知识点，是时候定义多态了，多态可以说是“一个接口，多种实现”或者说是父类的引用变量可以指向子类的实例，被引用对象的类型决定调用谁的方法，但这个方法必须在父类中定义，多态可以分为两种类型：编译时多态（方法的重载）和运行时多态（继承时方法的重写），编译时多态很好理解，运行时多态依赖于继承、重写和向上转型

变量类型

• 整型?
  byte 1字节 ? ? ? ? ? -128——127?
  short ?2 字节 ? ? ? ? -32,768 —— 32,767?
  int 4 字节 ? ? ? ? ?-2,147,483,648 ——2,147,483,647（超过20亿）?
  long 8 字节 ? -9,223,372,036,854,775,808 - 9,223,372,036854,775,807?
  java中所有的数据类所占据的字节数量与平台无关，java也没有任何无符号类型?

• 浮点类型?
  float 4 字节 ? ? ? ? 32位IEEE 754单精度（有效位数 6 – 7位）?
  double 8 字节 ? ? ? ? 64位IEEE 754双精度（有效位数15位）

• Unicode编码的字符单元?
  char ? ?2 字节 ? ? ? ? ?整个Unicode字符集?

• 真值类型?
  boolean ? ?1 位 ? ? ? ? ? ? True或者false?

• 封装类型?
  类class?
  接口interface
  数组array
  类Class引用
  接口引用

Java中的修饰符

大概可以分三种，分别是类修饰、属性变量修饰、方法修饰等。

• public
  类修饰：将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。
  属性变量修饰：指定该变量为公共的，他可以被任何对象的方法访问。
  方法修饰：指定此方法是公共的，所有人都可以调用

• protected
  类修饰：只能修饰内部类
  属性变量修饰：在同一个包中的类或者子类可以访问，其他包中的类不能访问。
  方法修饰：指定该方法可以被其他同包的类和子类进行访问。
  ?
• 默认
  类修饰：只有在相同包中的对象才能使用这样的类。
  属性变量修饰：同一个包中的类可以访问，其他包中的类不能访问，子类也不能访问。
  方法修饰：同一个包中的类可以访问，其他包中的类不能访问，子类也不能访问。
  ?
• private
  类修饰：只能修饰内部类
  属性变量修饰：指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。
  方法修饰：指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）
  ?
• final
  类修饰：将一个类生命为最终（即非继承类），表示他不能被其他类继承。
  属性变量修饰：最终修饰符，指定此变量的值不能变。
  方法修饰：指定该方法不能被重载。
  ?
• static
  类修饰：只能修饰内部类
  属性变量修饰：（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
  方法修饰：指定不需要实例化就可以激活的一个方法。
  ?
• abstract
  类修饰：将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。
  属性变量修饰：不能修饰属性变量
  方法修饰：只有在抽象类中修饰方法，且被修饰的方法不能有方法体，需要在子类中实现。
  ?
• interface
  类修饰：将一个类声明为接口类，所有方法没有实现，需要子类提供方法实现。
  属性变量修饰：不能修饰属性变量。
  方法修饰：不能修饰方法。
  ?
• synchronized
  类修饰：将一个类声明为接口类，所有方法没有实现，需要子类提供方法实现。
  属性变量修饰：不能修饰属性变量。
  方法修饰：不能修饰方法。
  ?

• volatile
  类修饰：不能修饰类。
  属性变量修饰：修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。一个 volatile 对象引用可能是 null。
  方法修饰：不能修饰方法。

• transient
  类修饰：不能修饰类。
  属性变量修饰：（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。
  方法修饰：不能修饰方法。
  ?

• native
  类修饰：不能修饰类。
  属性变量修饰：不能修饰属性变量。
  方法修饰：本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。
  

Java基础入门概念

原文：https://www.cnblogs.com/yuanjiangnan/p/12543389.html