java基础入门笔记（一）

标识符：

标识符就是用于给java程序中变量，类，方法等命名的符号

标识符命名规则：

1. 标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符，不能以数字开头。譬如：123name 就是不合法滴
2. 标识符不能是 Java 关键字和保留字（ Java 预留的关键字，以后的升级版本中有可能作为关键字），但可以包含关键字和保留字。如：不可以使用 void 作为标识符，但是 Myvoid 可以
3. 标识符是严格区分大小写的。 所以涅，一定要分清楚 imooc 和 IMooc 是两个不同的标识符哦！
4. 标识符的命名最好能反映出其作用，做到见名知意。

java中的数据类型

java语言是一种强类型语言。通俗点说就是，在java中存储的数据都是有类型的，而且必须在编译时就确定其类型。java中有两类数据类型：

在java领域里，基本数据类型变量存的是数据本身，而引用数据类型变量存的是保存数据的空间地址。说白了，基本数据类型变量里存储的是直接放在抽屉里的东西，而引用数据类型变量里存储的是这个抽屉的钥匙，钥匙和抽屉一一对应。

常用的基本数据类型：

注意：

String是一种常见的引用数据类型，用来表示字符串。在程序开发中，很多操作都要使用字符串来完成，例如系统中的用户名，密码，电子邮箱等。

java中变量的使用规则：

java中变量需要先声明后使用

变量使用时，可以声明变量的同时进行初始化,也可以先声明后赋值

String temp="hello!";

String love;
love="nihao";

变量中每次只能赋一个值，但是可以修改多次

String temp="hello","human";//这是错误的！变量只能赋一个值

main方法中定义的变量必须先赋值，然后才能输出

String temp;
System.out.println("变量temp的内容："+temp);
//这是错位的，temp没有赋值。

虽然语法没有提示错误，但是实际开发中，变量名不建议使用中文，容易产生安全隐患，譬如跨平台操作时出现乱码等等

String name="张三";

java中的自动类型转换：

在java程序中，不同基本数据类型的数据之间经常需要进行相互转换，例如

int score1=82;
double score2=score1;
system.out.println(score2);

代码中int型变量score1可以直接为double型变量score2完成赋值操作，运行结果是：82.0
这种转换成为自动类型转换

java自动类型转换需要满足的条件：

目标类型能与源类型兼容，如double型兼容int型，但是char型不能兼容int型

int age=19;
char sex='女';
char result=age+sex;//int类型不能自动转换为char类型

目标类型大于源类型，如double类型长度为8字节，int型为4字节，因此double类型的变量里可以直接存放int型数据，但是反过来就不可以了。

java中的强制类型转换

问题：当程序中需要将double型变量是值赋给一个int型变量，该如何实现呢？
答：显然，这种转换时不会自动进行的，因为int型的存储范围比double型小，因此这是就需要通过强制类型转换来实现了。

语法：（数据类型）数值

double avg1=75.8;
int avg2=(int)avg1;//将double型强制转换为int型
System.out.println(avg1);
System.out.println(avg2);

注意：

  强制类型转化可能会造成数据丢失，所以一定要慎重。

java关键字final、static的使用

1、final

java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
  final类不能被继承，没有子类，final类中的方法默认是final的。
  final方法不能被子类的方法覆盖，但可以被继承。
  final成员变量表示常量，只能被赋值一次，赋值后值不能再被改变。
  final不能用于修饰构造方法。
  注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

final变量（常量）

    用final修饰的成员变量表示常量，值一旦给定就无法改变！
    final修饰的变量有三种:静态变量、实例变量、和局部变量，分别表示三种类型的常量。

语法：final 常量名=值；

程序中使用常量可以提高代码的可维护性。例如，在项目开发时，我们需要指定用户的性别，此时可以定义一个常量SEX，赋值”男”，在需要指定用户性别的地方直接调用此常量即可，避免了用户的不规范赋值导致程序出错的情况。
注意：常量名一般使用大写字符。

2、static

1、static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态代码块，但是java语言没有全局变量的概念。
2、被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，java虚拟机就能根据类名在运行时数据区的方法区内定找到他们，因此，static对象可以在它任何对象创建之前访问，无需任何引用任何对象。
3、用public修饰static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享一个同一个static变量。
4、用private修饰static，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用–废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。
5、static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
    类名.静态方法名(参数列表…)
    类名.静态变量名
    用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块。

java使用注释：

在编写程序时，经常需要添加一些注释，用以描述某段代码的作用。
一般来说，对于一份规范的程序源代码而言，注释应该占到源代码的 1/3 以上。因此，注释是程序源代码的重要组成部分，一定要加以重视哦！
Java 中注释有三种类型：单行注释、多行注释、文档注释：

/**
*这是文档注释
*文档注释以/**开头
*/ 
public class teach{
    /* 
    *这是多行注释
    *可以包含多行内容
    */
    public static void main(String[] args){
    //这是单行注释
    System.out.println("hello world");
    }
}

注意：我们可以通过javadoc命令从文档注释中提取内容，生成程序的API帮助文档。

java输入

使用Scanner工具类来获取用户输入的信息，Scanner类位于jave.util包中，使用时需要导入此包。
1，导入jave.util.Scanner
2，创建Scanner对象
3，接收并保存用户输入的值

import java.util.Scanner; //导入
public class teach {
    public static void main (String[] args){
      Scanner input=new Scanner(System.in);//创建Scanner对象
      System.out.println("请输入考试成绩信息：");
      int score=input.nextInt();//获取用户输入的成绩并保存在变量中
      System.out.println("加分前的成绩："+score);
        }
}

注意：Scanner input=new Scanner(System.in);
扫描从控制台输入的字符,Scanner是用于扫描输入文本的类名，input仅仅是对象名，你可以换成任意的非java保留着，如a、b、c都行，new是给对象new（开辟）一个空间存储扫描进来的东西，System.in 是PrintStream（字节打印流）的一个实例 ，只能按字节读取。
Scanner -是java类库的一个基础类,一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器。
input -声明的变量名
new Scanner() -给变量input分配空间,初始化,实例化
System.in -参数, 这里就是获取输入流的意思

java条件语句之switch

执行过程：当switch后表达式的值和case语句后的值相同时，从该位置向下执行，直语句块到遇到break语句或者switch语句块结束；如果没有匹配的case语句则执行default代码。

注意：

1，switch后面小括号中表达式的值必须是整型或字符型
2，case后面的值可以是常量数值，如1,2；。也可以是一个常量表达式，如2+2；但不能是变量或者带有变量的表达式，如a*2
3，case匹配后，执行匹配块里的程序代码，如果没有遇见break会继续执行下一行的case块里的内容，直到遇到break语句或者switch语句块结束。
如：

int num=1;
switch(num){
case 1:
      System.out.println("奖励笔记本一台");
case 2:
      System.out.println("奖励雨伞一把");
case 3:
      System.out.println("奖励U盘一个");
default:
      System.out.println("谢谢参与");

结果：

4，可以把功能相同的case语句合并起来，如

case 1:
case 2:
System.out.println("奖励U盘一个");

数组

声明一维数组有两种方式：

1，数据类型[] 数组变量
  eg: int[]   a;
2，数据类型 数组变量[]
  eg:int  a[];
###分配空间
简单的说，就是指定数组中能存储多少个元素，如：

 scores=new int [5];//长度为5的整数数组
 height=new double[5];//长度为5的浮点型数组
 name=new String[5];//长度为5的字符串数组
 int a[]={1,2,3}; //数组初始化

我们也可以在声明数组的同时分配空间：
int[] scores=new int[5];

数组长度length

获得数组长度：
数组名.length

for语句作用于数组的逐元循环

for(类型 变量：数组)

用数组输出杨辉三角

import java.util.Scanner;

import org.w3c.dom.NamedNodeMap;

public class experiment3 {
    public static void main(String[] args) {
        System.out.print("请杨辉三角行数：");
        Scanner input = new Scanner(System.in);// 从控制台输入一个数
        int n = input.nextInt();
        int[][] a = new int[n][n];
        for (int i = 0; i < n; i++) {
            a[i][0] = a[i][i] = 1;
            for (int j = 1; j < i; j++)
                a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
        }
        print(a);
    }

    public static void print(int a[][]) {
        int m = a.length;
        int i, k;
        for (i = 0; i < m; i++) {
            for (k = 0; k < 2 * (m - i) - 1; k++)
                System.out.print(" ");
            // 字符前的输出空格
            for (int j = 0; j <= i; j++) {
                System.out.print(a[i][j] + "   ");
            }
            System.out.println();
        } // 输出数组里的内容
    }
}

类

类：描述对象的数据类型，刻画一组具有相同共同特性的对象。
语法格式：
 类声明
 {
 成员变量；
 成员方法；
 }

public class Demo3_2 {
    static int i=1; //成员变量
    static
    {
        System.out.println("执行了一次");
        //该静态区域块只执行一次,不创建对象，也会执行一次。
        i++;        
    }
    public  Demo3_2() //构造函数，成员方法
    {
        i++;
    }
    public static void main(String args[]){
        Demo3_2 t1=new Demo3_2();
        System.out.print(t1.i);
        Demo3_2 t2=new Demo3_2();
        System.out.println(t2.i);   
    }
}

结果：3 4

类的成员方法

语法格式：
 [修饰符] 返回值类型 方法名（[参数列表]）
注意：类方法中不能访问静态变量（类变量）

public class Stu {
    int age;
    String name;
    int fee;
    static int totalFee;
    public Stu(int age,String name,int fee)//类方法
    {
    this.age=age;
    this.name=name;
    this.fee=fee;
    totalFee+=fee;
    }
    public static int getTotalFee()
    //java中规则，类变量原则上用类方法去访问和操作
    {
        //age++;  这里是错误的。类方法中不能访问静态变量（类变量）
        return totalFee;
    }
    public static void main(String args[]){
        Stu stu1=new Stu(29,"aa",344);
        Stu stu2=new Stu(28, "dd", 322);
        System.out.println(stu1.getTotalFee());
    }
}

注意：通过一个成员方法去控制和访问私有的属性。

创建一个成员变量去访问私有属性

包

java API常用的包

包名	功能
java.lang 语言包	java语言核心类库包含java语言必不可少的系统类定义，包括Object类，基本数据类型封装类，数学运算，字符串，线程，异常处理等
java.util 实用包	工具类库，包含日期类，集合类库等
java.awt 抽象窗口工具包	提供构建图像用户界面的类库，包含组件，事件及绘图功能等
java.applet	提供Applet应用程序
java.text 文本包	提供各种文本或日期格式
java.io 输入输出流包	提供标准输入输出流及文件操作类库
java.net 网络包	提供与网络编程有关的类库，包括Socket通信支持，Internet访问支持等。
java.sql	提供数据库应用功能的类库
java.swing	扩充和增强图形用户界面功能的类库

包-引入

语法：import 包

继承

继承可以解决代码复用，让我们编程更加靠近人类思维。当多个类存在相同属性和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends语句来声明继承父类的某些属性和方法：
语法结构：class 子类 extends 父类
如：下面这几个关于学生的类显得比较冗余：

//小学生
class Pupil
{
    //定义成员属性
    private int age;
    private String name;
    private float fee;
    //缴费
    public void pay(float fee)
    {
        this.fee=fee;
    }
}
//中学生
class MiddleStu{
    //定义成员属性
        private int age;
        private String name;
        private float fee;
        //缴费
        public void pay(float fee)
        {
            this.fee=fee*0.8f;
        }   
}
//大学生
class ColStu
{
    //定义成员属性
        private int age;
        private String name;
        private float fee;
        //缴费
        public void pay(float fee)
        {
            this.fee=fee*0.1f;
        }

通过继承改进后的代码：

//将学生的共同属性提取出来做一个父类
class Stu{
    //定义成员属性
     public int age;
     public String name;
     public float fee; //缴费
     public void printName()
     {
     System.out.println("名字："+this.name);
     }  
}
//小学生
class Pupil extends Stu
{
    public void pay(float fee)
    {
        this.fee=fee;
    }
}
//中学生
class MiddleStu extends Stu
{
        public void pay(float fee)
        {
            this.fee=fee*0.8f;//打八折
        }   
}
//大学生
class ColStu extends Stu
{
        public void pay(float fee)
        {
            this.fee=fee*0.7f; //打七折
        }
}

父类可被继承的成员和方法：

并不是所有父类的属性和方法都可以被继承，可被继承的有：
 1、子类不能访问父类的私有成员，包括成员变量和成员方法。
 2、子类能够访问父类的公有成员和保护成员。
 3、子类对父类发缺省权限成员的访问控制，以包为界分为两种情况，可以访问当前包中父类的缺省权限成员，不能访问其他包中父类的缺省权限成员。

继承的注意事项：

子类最多只能继承一个父类（指直接继承）
java所有类都是Object类的子类。

方法重载

类中可以有多个同名的成员方法，前提是参数类表不同，称为类的方法重载，就是类的同一种功能的多种实现方式，到底采用那种方法取决于调用者给出的参数。
如：

public class Demo2 {
    public static void main(String [] args)
    {
        Abc abc1=new Abc();
        System.out.println(abc1.getMax(1, 2));
    }
}
class Abc
{
    //返回最大值
    public int getMax(int i,int j)
    {
        if (i>j)
            return i;
        else return j;
    }
    public float getMax(float a,float b) //方法重载
    {
        if (a>b)
            return a;
        else return b;
    }
}

方法重载注意事项：

  1、方法名相同
  2、方法的参数类型、个数、顺序至少有一项不同
  3、方法返回类型可以不同（只是返回类型不一样不能构成重载。）
  4、方法的修饰符可以不同（如果只是控制访问修饰符不同不能构成重载）

方法覆盖

子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的那个方法。

注意事项：

1、子类的方法的返回类型、参数、方法名称，要和父类方法的返回类型、参数、方法名称完全一致，否则编译出错。
2、子类方法不能缩小父类方法的访问权限。
覆盖如下例子：

public class Demo3 {
    public static void main(String[] args)
    {
        Cat cat1=new Cat();//创建一只猫
        cat1.cry();
        Dog dog1=new Dog();
        dog1.cry();
    }
}
class Animal
{
    int age;
    String name;
    public void cry()
    {
        System.out.println("我是动物，不知道怎么叫唤");
    }
}
//猫猫类
class Cat extends Animal
{
    //覆盖父类
    public void cry()
    {
        System.out.println("喵喵叫 ");
    }
}
//狗类
class Dog extends Animal
{
    //覆盖父类
    public void cry()
    {
        System.out.println("汪汪叫");
    }
}

结果：
 喵喵叫
 汪汪叫

多态性

一种定义，多种实现。所谓多态，就是一个引用（类型）在不同情况下的多种状态。

public class Demo5 {
    public static void main(String[] args){
    /*Cat cat1=new Cat();
    cat1.cry();
    Dog dog =new Dog();
    dog.cry();
    }
    */
    //多态实现
    Animal an =new Cat();
    an.cry();
    an=new Dog();
    an.cry();
    }
}
class Animal
{
    String name;
    int age;
    //动物会叫
    public void cry()
    {
        System.out.print("不知道怎么叫");
    }   
}
class Cat extends Animal
{
    //覆盖
    public void cry()
    {
        System.out.println("猫猫叫");
    }
}
class Dog extends Animal
{
    //覆盖
    public void cry()
    {
        System.out.println("汪汪叫");
    }
}

多态的实现例子：

public class Demo5 {
    public static void main(String[] args){
    Master master=new Master();
    master.feed(new Dog(),new Bone());
    master.feed(new Cat() , new Fish());
    }
}
class Master 
{
    //喂动物,使用多态，
    public void feed(Animal an,Food f)
    {
        an.eat();
        f.showName();       
    }//即使增加动物种类，这里不需要改动！
}
class Food //创建食物
{
    String name;
    public void showName()
    {
        System.out.println("我不知道吃什么");
    }
}
class Fish extends Food
{
    public void showName()//覆盖父类的showName;
    {
        System.out.println("鱼");
    }
}
class Bone extends Food
{
    public void showName()//覆盖
    {
        System.out.println("骨头");
    }
}
//动物类
class Animal
{
    String name;
    int age;
    //动物会叫
    public void cry()
    {
        System.out.print("不知道怎么叫");
    }
    //动物吃东西
    public void eat()
    {
        System.out.println("不知道吃什么");
    }   
}
class Cat extends Animal
{
    //覆盖
    public void cry()
    {
        System.out.println("猫猫叫");
    }
    public void eat()
    {
        System.out.println("猫猫爱吃鱼");
    }
}
class Dog extends Animal
{
    //覆盖
    public void cry()
    {
        System.out.println("汪汪叫");
    }
    //
    public void eat()
    {
        System.out.println("狗狗吃骨头");
    }
}

结果：

多态注意事项：
1、java允许父类的引用变量引用它的子类型的实例（对象），反之不行。
 eg:Animal animal=new Animal();
 这种转换时自动完成的。