Java学习笔记(持续更新)

前言

这篇学习笔记我仅仅出于个人角度与大家共同交流学习，因此我可能会着重于语法和例题，这是我这篇文章重点难点。因此关于配置和某些需要了解的背景部分我会跳过并引用很多大佬文章的链接来填补。

1.java入门

提示：Java的发展历程需要了解，但内容我就不再罗列整理，具体可以看这一篇大佬文章

http://t.csdn.cn/dDCP4

对象：由属性（外观），方法（行为），事件（交互）所描述的客观存在。

特点：平台无关性（虚拟机技术） 平台（操作系统+cpu）

           多线程

            动态转载（jre虚拟机）

1.1安装JDK

这部分的重点是配置环境变量，具体可以看这篇大佬文章

http://t.csdn.cn/PJm84

1.2 引用只有一个方法的基础例题

2.基本数据类型与数组

2.1标识符与关键字

标识符：

由字母、下划线、美元符号和数字组成。

第一个字符不能是数字字符。

不能是关键字。

不能是布尔值或NULL。

关键字：

用于定义数据类型的关键字：class、interface、enum、byte、short、int、long、float、double、char、boolean、void

用于定义数据类型值的关键字：true、false、null

用于定义流程控制的关键字：if、else、switch、case、default、while、do、for、break、continue、return

用于定义访问权限修饰符的关键字：private、protected、public

用于定义类、函数、变量修饰的关键字：abstract、final、static

用于定义类和类之间关系的关键字：extends、ipplements

等等

特点：关键字的所有字母都为小写、不能作为标识符

2.2 基本数据类型

我们一般说有8种，总结一下是整数类型，逻辑类型，浮点类型和字符类型4种。

整数类型：byte，1字节，8位，最大存储数据量是255，存放的数据范围是-128~127之间。

                short，2字节，16位，最大数据存储量是65536，数据范围是-32768~32767之间。

                int，4字节，32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。

                long，8字节，64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。

浮点类型：float，4字节，32位，有效数字8位，超过的四舍五入。数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F，例如:452.54F.

                double，8字节，64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。

提示：后缀不写时默认double。2e40f(2*10^4,指数表示法)。

字符型：char，2字节，16位，存储Unicode码，用单引号赋值。

布尔型：boolean，只有true和false两个取值。

提示:一个Byte(字节)等于8bit（位），位是最小单位。并且汉字是一个两字节。

定义格式：

变量：int x=100;

常量：final intx=100;

2.3 基本数据类型封装器类的构造方法

所以，以Byte为例，构造方法为

public Byte(byte value)

构造一个新分配的 Byte对象，该对象表示指定的 byte值。 
参数 
value -值由表示 Byte 。

2.4 类型转换运算

基本类型按精度从低到高：byte short char int long float double

转换格式：（类型）表达式；

例1： b=(byte)n;  //精度高的类型转换为低精度，导致了精度损失。

        d=(double)f;

2.5 数据的输入和输出

1. 用Scanner创建对象输入：

Scanner input = new Scanner(System.in);

意思是 从键盘获取输入，用Scanner读取，以此类获得输入信息。

2.reader对象调用，读取用户在命令行输入的各种基本类型数据。

int a=reader.nextlnt(); //以int整型为例

 其余格式

 使用System类中的方法实现数据输出

System.out.println(表达式);
System.out.print(表达式);

前者输出数据后换行，后者不换

中间的并置符号用“+”

 例题2：输入若干数字，每输入一个都要按回车确认，键盘输入0结束操作，程序计算和。

 2.6 数组

引用型变量，复合数据类型，所以要用new申请空间。

2.6.1 声明数组

数组的元素类型 数组名 []； //中括号里不能有长度数字

数组的元素类型 [] 数组名；

分配元素格式：

数组名 = new 数组的元素类型 [数组元素的个数]；// 个数可以是变量

例： boy = new float[4];

声明和分配元素同时完成：

float boy [] = new float[4];

 数组初始化

float boy [] ={2,3,4,2.0f,3.3,778.98f};

3.运算符，表达式和语句

（带着C的底色讲，很多相同常识就不赘述）

 3.1 运算符与表达式

3.1.1 算术运算符与表达式

数据类型精度从低到高排列： byte short char int long float double

例如：5/2得不到2.5 按精度高的运行，所以要得到2.5的值，要写5.0/2

运算先后 例题：

class Test
{    public static void main(String args[])
    {    int x,y=10;
         if( ((x=0)==0 || ((y=20)==20) )
        {
              System.out.println("y="+y);
         }
     }
}

小提示：||运算一个为真值为真，所以后面的表达式不执行，y仍然等于10

instanceof运算符

二目运算符，左边一个对象，右边一个类，当左边对象是右边的类或子类创建的对象时，运算结果为true,反之false；

扩充知识点：每个类都使Object类作为自己的超类。

3.2 语句概述

Java语句分为六类：

方法调用语句：如输入输出语句

表达式语句：如赋值语句

复合语句：用{}把一些语句括起来构成复合语句

空语句

控制语句：条件，循环等

package语句（引入包语句）和import语句（引入类库） //第四章详解

3.3 if条件分支语句

用法与C类似，但表达式必须是Boolean型，不能用0/1代表true和false。

3.4 switch开关语句

用法与c类似，表达式必须是byte,short型。

3.5 循环语句

for,while等都与c类似，break和continue都与c类似

3.6 for语句与数组

语法格式如下：

for(生命循环变量：数组的名字){......}

其中，声明的循环变量类型必须和数组的类型相同。

例：

int a[]={1,2,3}

        for(int i:a){

        ......                

}

4. 类与对象

温馨提示：4，5，6，7章是大重点！！核心内容！！

4.1 类 引入

在面向对象语言中，把方法和类（主语）捆绑起来实现某功能，所以方法和类之间有所属关系。

类是对对象的抽象。

Java的源程序是由很多类组成。

类是Java语言中最重要的“数据类型”，类声明的变量被称为对象。所以说 类是用来创建对象的模板。 这种“数据类型”是复合数据类型，所以申请地址空间要用new实现。

定义：  类声明和类体

定义类的一般格式：

class  类名{

                        类体

                        }

提示：类名的第一个字母大写，类名要是合法的Java标识符。

public class  类名必须和文件名同名。

在类中，变量分为成员变量和局部变量。

成员变量又分为实例成员变量和类变量（静态变量）, 类变量前面一般会加上关键字 static.

4.1 类声明

写类的目的是为了描述一类事物共有的属性和功能（方法）。

4.2 类体

两部分构成：一部分是成员变量的声明，其余的语句都封装到另一部分的方法语句里面。

方法的定义部分：由局部变量和语句组成。

class Tom{
    int x=10,y;  //局部变量
    void f(){
        int x=5;  //成员变量，所以x=10被屏蔽
        y=x+x;  //值为10
    }
}

如果想在改方法中使用被屏蔽的成员变量，可以用this关键字

class Tom{
    int x=10,y;  //局部变量
    void f(){
        int x=5;  //成员变量，所以x=10被屏蔽
        y=x+this.x;  //值为15,因为this表示类的实例变量
    }
}

在使用局部变量之前，必须保证它有具体的值，因为局部变量没有默认值。

4.2.1 方法

定义方法包括两部分：方法声明和方法体。

一般格式：

int add(int x,int y,int z) {  //有参数
// 返回值类型 方法名称（参数）
        { 
            return x+y+z;  //方法体内容
}

4.2.3 类方法和实例方法

类名前加关键字static的是 类方法

类方法的调用格式：  类名.方法

4.2.4 方法的分类

构造方法：名字必须和所在的类的名字完全相同，没有类型。

重载方法：一个类中可以有多个方法有相同方法名，但必须参数个数或类型不同。方法的返回类型和参数类型的名字不参与比较。

方法重载是一种多态的体现。

注意：实例方法可以对两种变量操作，但类方法只能对类变量操作。

        一个类中的方法可以互相调用。

4.3构造方法与对象的创建（第四章重点）

构造方法：对对象进行初始化的方法

名字必须和所在的类的名字完全相同，没有返回值类型。

构造方法允许重载。（构造方法不唯一）

构造方法的作用是在创建对象时使用，对各个成员变量初始化。

如果类中没有编写构造方法，系统会默认分配一个。

4.3.1 创建对象

声明对象 一般格式为： 类名 对象名

为声明的对象分配变量 使用new运算符和类的构造方法，并返回一个引用值给对象名称。

例：

class XiyoujiRenwu {
  float height,weight;
  String head, ear;
  void speak(String s) {
    System.out.println(s);
  }
}
public class Example4_1 {
  public static void main(String args[]) {
    XiyoujiRenwu zhubajie;       //声明对象
    zhubajie = new XiyoujiRenwu(); 
   }
} 

合并格式： 类的名字 对象的名字 = new 类的构造方法名（参数）

4.3.2 对象的引用和实体

一个类创建的两个对象，如果有相同的引用地址，那么就具有完全相同的实体。

4.4 参数传值

一个类存放在一个类文件中，便于维护和差错。

方法被调用时，参数变量必须有具体的值。

对于基本数据类型的参数，传递的是值的拷贝，“单向的值传递”。

对于参数是复合数据类型时，传递的是引用地址（成员变量的地址带运算出的地址契约），“双向的值传递”，Java的引用型数据类型包括对象，数组，接口。（地址共享）

4.5 对象组合（重点）

对象组合的实质：一个类A的成员变量中，有成员变量是有另一个类B定义的对象，就叫类A组合了类B的对象。

例：

class 教师{
    void speakjava(){
        ......
    }
}

class 学校{
    教师 Li ； //因为它的成员变量有另一个类定义的对象，所以学校类组合了教师类
    void 上课（）{
        Li.speakjava();
    }    
}

public class Test{
    public static void main(String args[]){
        学校 strat=new 学校（）；
        strat.上课（）  //对学校实体化
//同理，学校组合了教师
    }
}

核心思想：如果对象a组合了对象b,对象a以组合的方式复用对象b

注意：一个类声明的两个对象如果具有相同引用地，二者就具有完全相同的变量。

类是模型，没有储存空间，类不能组合到新类中，类定义的对象可以。

在类中的复合数据类型：类，接口，字符串定义的对象实际上都是对象组合。

用法：

1.在C类中组合一个A类的对象a和B类的对象b.

2.在B类中组合定义一个A类的对象a1。

3.在C类中B类只new一次，创建一个对象，A类被new多次创建多个对象，A类产生对象参数传递给B类中的a1对象，实现引用地址完全相同从而让a1对象在B类中解决各种问题。

代码实现：

public class C{
    public static void main(String args[]){
        A a =new A();
        aa =new A();
        B b =new B();
        a.age=15;
        aa.age=30;
        b.setA(a);
        System.out.println(b.ret()))
    }
}

public class A{
    int age;
    int addage(){
        return age+20;
    }
}

public class B{
    A a1;
    void setA (A aaa){
        a1 aaa;
    }
    int ret(){
        return(a1.addage());
    }
}

4.6 实例成员和类成员

方法声明时，方法类型前面不加关键字static修饰的是实例方法、加static关键字修饰的是类方法(静态方法)。

类变量不管创建几个变量，只有一个共用的存储空间。

4.7 this关键字

this可以出现在实例方法和构造方法中，但不可以出现在类方法中。

this关键字出现在类的构造方法中时，代表使用该构造方法所创建的对象. 当this关键字出现实例方法中时，this就代表正在调用该方法的当前对象。

格式：this.实例变量

        this.实例方法

4.8 包

通过关键字package声明包语句。

package语句作为Java源文件的第一条语句， 为该源文件中声明的类指定包名。

package语句的一般格式为：                   package 包名;

4.9 import语句

格式：import 导入声明的类 ；

例：import java.util.*表示引入util包中的所有类。

4.10 权限访问

访问限制修饰符有private、protected和public，没有被修饰符修饰的类统统是友好类，被称为friendly类。

4.11 基本类型的类封装

Java提供了基本数据类型相关的类，实现了对基本数据类型的封装。 Byte、Integer、Short、Long、Float、Double和Character类。这些类在java.lang包中，用new申请地址。

4.12 对象数组

格式： 类名 [] 数组名 = new 类名[10];

5.子类与继承

Java的四大特性：

封装性：把对象的属性和方法结合成一个独立的整体，隐藏实现细节，并提供对外访问的接口。

继承性：

                继承：从已知类中派生出一个新的类，叫做子类，子类可以实现父类所有非私有化的属性和方法，再根据实际情况拓展新的程序功能。

多态性：不同对象对同一个消息做出响应，消息对不同对象采用不同方法，通过子类继承的方法重写和对象的上转型对象实现。

抽象性：通过特定的实例取出共同的特征形成一个概念。

        抽象类（abstract class）：属性 抽象方法

        抽象方法：

                        被abstract修饰的方法。

                        没有方法体。

                        修饰符返回类型为 方法名（）{}；

                        不能被final，static，private修饰。

5.1 子类和父类

##注意：任何子类只能有一个父类。

声明子类格式：

class 子类名 extends 父类名 {
    ....
}

##Object是所有类的祖先类，根节点。 

##Java.lang包是默认包不需要import声明。

5.2 子类的继承性

访问控制权限

        一般放在类名之前，方法名之前，属性名之前。

 5.3 子类和对象

子类创建对象时的构造方法：1.调用父类构造方法，2.调用子类自己的构造方法进行创建。

##如果在多个父类构造方法中没有指定使用哪一个，那么就调用父类不带参数的构造方法。

##子类可以通过父类继承的方法对它没有继承的父类中的变量和方法进行操作。

5.4 成员变量的隐藏和方法重写（本章重点）

5.4.1 成员变量的隐藏

对于子类从父类继承的成员变量，如果子类声明的成员变量和父类同名，子类就隐藏了继承的成员变量。在子类中操作时，操作的就是重新声明的成员变量，原来的父类成员变量被隐藏。

但是从父类继承的方法在子类中运用时，它的操作就是对于被隐藏的父类成员变量。

5.4.2 方法重写

子类可以重写可以隐藏已继承的父类方法。目的是把父类的状态和行为变成自己的状态和行为。

重写的语法规则：

如果子类继承了父类的实例方法（不加static的方法），那么它就有权重写这个方法。

重写：子类中定义一个方法，它的类型和父类方法的类型或父类的viod部分的子类型一致，且这个方法的名字，参数的个数和类型完全相同。不能满足以上的参数部分的条件叫做重载。

重载方法：一个类中可以有多个方法有相同方法名，但必须参数个数或类型不同。方法的返回类型和参数类型的名字不参与比较。

格式：子类的方法和父类的方法的返回值，方法名，参数个数和类型保持一致。

##被子类重写的方法不能拥有比父类方法更严格的访问权限。

5.5 super关键字

用super操作被隐藏的成员变量和方法。

格式：super.属性  super.方法

用在调用父类构造方法时格式： super(参数)；（在子类中创建对象时可以用到），必须在子类构造方法的第一行。

final类不能被继承，不能有子类，更不允许重写。

5.6 对象的上转型对象（重点）

设A类时B类的父类，用子类创建一个对象，并把这个对象的引用放到父类的对象中，我们说对象a是对象b的上转型对象。

##上转型对象不是父类实例化的对象。

上转型对象的功能和限制：不能操作子类新增的成员变量，不能调用子类新增的方法。

                                           可以访问子类继承或隐藏的成员变量，可以调用子类继承的方法或子类重写的实例方法。

5.7 继承与多态（重点）

多态性实质： 通过父类定义的上转型对象，调用各个子类被重写子类方法，可以各自调用子类功能的行为。

5.7.1 abstract类和abstract()方法

用关键字abstract修饰的类或方法被称为抽象类或抽象方法。

##抽象方法没有方法体，没有{}

abstract类的特点：对于abstract方法，只允许声明不允许实现，而且不允许使用final修饰抽象方法。

                                不能使用new运算符创建抽象类的对象，只能产生其子类。

                                如果一个类是abstract类的子类，那么它必须具体实现父类的所有abstract方法。

5.7.2 面向抽象编程

1.通过抽象类和抽象方法制定行为标准。

2.通过子类继承，在子类中对所有的抽象方法进行重写。

3.通过抽象类定义子类上的上转型对象。

4.通过上转型对象和抽象方法名，实现对象的多态。

5.在制定标准时，多用继承，在前端开发，多用对象组合。