Java基础知识

1. java的基本数据类型

在Java中数据类型分为基本数据类型和引用数据类型。
基本数据类型：int,float,double等等，创建变量如：int temp = 1;
引用数据类型: 类，String,System,数组等，这里创建的是对象，如：Animal one = new Animal();

2.java中的类和对象

我们身边有很多对象（不是女朋友！！），猫，狗，人等等。所有这些对象都有自己的状态和行为。
比如人，它的状态有：名字、性别、肤色。行为有：吃饭，睡觉，打游戏和学习。而类是一个模板，它描述一类对象的行为和状态。
生物就是个类，它可以被实例化，人这个类一个实例化的结果，而对象就是用来实例化一个类。

在java中对象也有状态和行为，对象的状态就是属性，行为通过方法体现。

类可以看成是创建Java对象的模板。

下面通过两个例子先了解一下类和对象：

public class Dog{
String breed;
int age;
String color;
void barking(){
}
void hungry(){
}
void sleeping(){
}
}//创建类

public class Puppy{
public Puppy(String name){
//这个构造器仅有一个参数：name，
System.out.println("小狗的名字是 : " + name );
}
public static void main(String[] args){
// 下面的语句将创建一个Puppy对象
Puppy myPuppy = new Puppy( “tommy” );
}
}

方法操作对象内部状态的 改变，对象的相互调用也是通过方法来完成。

类都是放在包里，一个包里不能有同名类

2.1类的继承

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

动物界的继承:草食动物和肉食动物都被动物所包括，它们都有动物的共同基本属性，也有自己的属性，用java的角度分析，他们吃东西的方法是不一样的，但他们的一些属性是一样的，比如都是动物。

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

类的继承格式
class 父类 {
}

class 子类 extends 父类 {
}

在java中不支持多继承，但支持多重继承，看下面图：

3.java中的方法

java方法是语句的集合，它们在一起执行一个功能。

方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用

方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：firstName

命名方法如下：

修饰符 返回值类型 方法名(参数类型 参数名){
…
方法体
…
return 返回值;
}

3.1构造方法

当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
构造方法分为有参构造方法和无参构造方法。

下面是两个分别使用有参和无参构造方法的例子：

// 一个简单的无参构造函数
class MyClass {
int x;
// 以下是构造函数
MyClass() {
x = 10;
}
}
public class ConsDemo {
public static void main(String args[]) {
MyClass t1 = new MyClass( 10 );//通过new对象来调用构造方法
MyClass t2 = new MyClass( 20 );
System.out.println(t1.x + " " + t2.x);
}
}

// 一个简单的有参构造函数
class MyClass {
int x;
// 以下是构造函数
MyClass(int i ) {
x = i;
}
}

通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。

一旦你定义了自己的构造方法，默认构造方法就会失效。
class MyClass {
int x;
// 以下是构造函数
MyClass(int i ) {
x = i;
}
//再加一个无参构造方法，那么再调用的时候，两个构造方法都能被使用，这是方法的重载
MyClass(){
}
}

不管你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法，默认构造方法的访问修改符和类的访问修改符相同(类为 public，构造函数也为 public；类改为 private，构造函数也改为 private)。

3.2Java 方法的重写(Override)

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

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

3.2.1 方法重写的规则

方法的重写规则：
1.参数列表必须完全与被重写方法的相同；
2.返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（就是类型为引用数据类型，就可以返回父类的另一个子类）
3.访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
4.父类的成员方法只能被它的子类重写。
5.声明为final的方法不能被重写。
6.声明为static的方法不能被重写，但是能够被再次声明。
7.子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
8.子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
9.构造方法不能被重写。
10.如果不能继承一个方法，则不能重写这个方法。

3.3Java 重载(Overload)

重载(overload) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法都必须有一个独一无二的参数类型列表。

比如有参构造方法和无参构造方法就是对方法的重载

MyClass(int i ) {
x = i;
}

MyClass(){
x =4；
}

注意：MyClass(int n) {
x = n;
}
这不是方法的重写，一定要区分开来，这只不过是换了一个形式参数而已，要关注的是数据类型，形式参数只起到传递值的效果，在这里的 int i 和int n是一样的

3.3.1重载规则

1.被重载的方法必须改变参数列表(参数个数或类型不一样)；
2.被重载的方法可以改变返回类型；
3.被重载的方法可以改变访问修饰符；
4.方法能够在同一个类中或者在一个子类中被重载。
5.无法以返回值类型作为重载函数的区分标准。

3.4Java重写(Override)与重载(Overload)的区别

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
访问	可以修改	一定不能做更严格的限制（可以降低限制）

4.java中常见的修饰符

java中有几种修饰符来改变访问权限：private,protected,public,默认（就是不写）

这些修饰符是改变访问权限的修饰符

访问修饰符	本类	同包	子类	跨包
private	✔
默认	✔	✔
protected	✔	✔	✔
public	✔	✔	✔	✔

注：

5.java中的关键字

5.1final

1.final修饰类
当用final去修饰一个类的时候，表示这个类不能被继承。
注：final类中的成员方法都会被隐式的指定为final方法

2.final修饰方法
被final修饰的方法不能被重写
注：一个类的private方法会隐式的被指定为final方法

3.修饰成员变量
（1）成员必须要赋初始值，而且只能是一次
（2）有两种方式赋值：
1.在构造代码块直接赋值
2.全部在构造方法中赋初值

（3）如果修饰的成员变量是一个引用类型，则是说这个引用的地址的值不能修改，但是这个引用所指向的对象里面的内容还是可以改变的。
（4）如果修饰的成员变量是基本类型，则表示这个变量的值不能改变

5.2static

1.static作用于某个字段，一个static字段对每个类来说只有一份存储空间，而非static字段是每个对象有一份存储空间。

2.static作用于方法的重要用法是不需要创建任何对象直接调用该static方法,这对于main()方法很重要。

3.static不能应用于局部变量。

4.Java中禁止使用全局方法，所以引入static方法通过类本身来直接调用。
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法直接通过类名.方法名调用
注意：static不能加类，在静态方法中不能用this。静态方法只能访问或调用静态变量或者静态方法，不能访问类的任何非静态成员变量和方法。

5.2.1静态代码块

{ //内容
}
这是构造代码块

static { //内容
}这是静态代码块

构造代码块在每次对象实例化的时候都会执行一次；而无论产生多少类实例，静态代码块只执行一次。每次都会优先执行静态构造代码块

5.2.2继承的初始化顺序

1.首先执行父类的静态变量辅助和静态代码块
2.执行子类的静态变量赋值和静态代码块
3.执行父类的成员变量赋值语句
4.执行父类的构造代码块，之后构造方法
5.执行子类成员赋值语句
6.执行子类构造代码块
7.执行子类构造方法

看下面代码：

public class Animal {
String name = “妮妮”;// 昵称
int month;// 月份
String species = “动物”;// 品种
static {
System.out.println(“我是父类的静态代码块”);
}
{
System.out.println(“我是父类的构造代码块”);
}
// 父类的构造不允许被继承、不允许被重写，但是会影响子类对象的实例化
public Animal() {
System.out.println(“我是父类的无参构造方法”);
}
public Animal(String name, int month) {
this.name = name;
this.month = month;
System.out.println(“我是父类的带参构造方法”);
}
// 吃东西
public void eat() {
System.out.println(this.getName() + “在吃东西”);
}
public void eat(String name) {
System.out.println(name + “在吃东西”);
}
}

public class Cat extends Animal
static{
System.out.println(“我是子类的静态代码块”);
}
{
System.out.println(“我是子类的构造代码块”);
}
public Cat(){
System.out.println(“我是子类的无参构造方法”);
}
public Cat(String name,int month){
/* 子类构造默认调用父类无参构造方法
* 可以通过super()调用父类允许被访问的其他构造方法
* super()必须放在子类构造方法有效代码第一行
*/
super(name,month); //this
System.out.println(“我是子类的带参构造方法”);
}

public class Test {
public static void main(String[] args) {
Cat one = new Cat();
}
}

输出结果：
我是父类的静态代码块
我是子类的静态代码块
我是父类的构造代码块
我是父类的无参构造方法
我是子类的构造代码块
我是子类的无参构造方法

5.3this

this关键字主要有三个应用：
(1)this调用本类中的属性，也就是类中的成员变量；
(2)this调用本类中的其他方法；
(3)this调用本类中的其他构造方法，调用时要放在构造方法的首行。

Public Class Student {
String name; //定义一个成员变量name
private void SetName(String name) { //定义一个参数(局部变量)name
this.name=name; //将局部变量的值传递给成员变量
}
}

应用一：引用成员变量
如上面这段代码中，有一个成员变量name，同时在方法中有一个形式参数，名字也是name，然后在方法中将形式参数name的值传递给成员变量name，虽然我们可以看明白这个代码的含义，但是作为Java编译器它是怎么判断的呢?到底是将形式参数name的值传递给成员变量name，还是反过来将成员变量name的值传递给形式参数name呢?也就是说，两个变量名字如果相同的话，那么Java如何判断使用哪个变量?此时this这个关键字就起到作用了。
this这个关键字其代表的就是对象中的成员变量或者方法。也就是说，如果在某个变量前面加上一个this关键字，其指的就是这个对象的成员变量或者方法，而不是指成员方法的形式参数。为此在上面这个代码中，this.name代表的就是对象中的成员变量，又叫做对象的属性，而后面的name则是方法的形式参数，代码this.name=name就是将形式参数的值传递给成员变量。这就是上面这个代码的具体含义。
一般情况下，在Java语言中引用成员变量或者成员方法都是以对象名.成员变量或者对象名.成员方法的形式。
从这个应用中，我们可以看出this关键字其代表的就是对象的名字。

应用二：调用类的构造方法
public class Student { //定义一个类，类的名字为student。
public Student() { //定义一个方法，名字与类相同故为构造方法
this(“Hello!”);
}
public Student(String name) { //定义一个带形式参数的构造方法
}
}
this关键字除了可以调用成员变量之外，还可以调用构造方法。
应用三：返回对象的值
this关键字除了可以引用变量或者成员方法之外，还有一个重大的作用就是返回类的引用。如在代码中，可以使用return this，来返回某个类的引用。此时这个this关键字就代表类的名称。如代码在上面student类中，那么代码代表的含义就是return student。可见，这个this关键字除了可以引用变量或者成员方法之外，还可以作为类的返回值，这才是this关键字最引人注意的地方。

5.4super

package test;

class FatherClass {
public int value;
public void f() {
value=100;
System.out.println(“父类的value属性值=”+value);
}
public FatherClass(){
System.out.println(“FatherClass constructor”);
}
}

class ChildClass extends FatherClass {
/**
* 子类除了继承父类所具有的value属性外，自己又另外声明了一个value属性，
* 也就是说，此时的子类拥有两个value属性。
/
public ChildClass(){
super();
System.out.println(“ChildClass constructor”);
}
public int value;
/
* 在子类ChildClass里面重写了从父类继承下来的f()方法里面的实现，即重写了f()方法的方法体。
*/
public void f() {
//使用super作为父类对象的引用对象来调用父类对象里面的f()方法
System.out.println(super.value); //100
}
}
public class SuperKeyTest {
public static void main(String[] args) {
ChildClass cc = new ChildClass();
cc.f();
}
}
1.super可以用来访问父类的成员方法或变量，当子类成员变量或方法与父类有相同的名字时也会覆盖父类的成员变量或方法，这个时候要想访问父类的成员变量或方法只能通过super关键字来访问，子类方法中的super.方法名()不需要位于第一行。
2.当需要在子类中调用父类的被重写方法时，要使用super关键字，

class Animal{
public void move(){
System.out.println(“动物都可以跑”);
}
}

class Dog extends Animal{
public void move(){
super.move(); // 应用super类的方法，要位于第一行
System.out.println(“狗还可以游泳”);
}
}

public class TestDog{
public static void main(String args[]){
Animal b = new Dog(); // Dog 对象
b.move(); //执行 Dog类的方法
}
}

以上实例编译运行结果如下：
动物都可以跑
狗还可以游泳
3.引用构造函数
super(参数)：调用父类中的某一个构造函数（必须是构造函数中的第一条语句）
注意：this也可以调用构造函数，this和super在构造函数里不能一起使用，因为都要放在第一行。

5.5this和super总结

this	super
当前类对象的引用	父类对象的引用
访问当前类的成员方法和属性	访问父类的成员方法
访问当前类的构造方法，this()	访问父类的构造方法，super()
不能在静态方法中使用	不能在静态方法中使用