Java 入门基础了解：

一：java基础

1. Java是面向对象的语言，我们想要了解Java 我们可以先了解Java语句的主体结构，一段Java语言的基本单位就是Class，Java语句是以 修饰符+类的关键字+类名+{一个类的方法}  一个类的方法又可以分为 修饰词+ 返回值 + 方法名+（参数）+{方法体：为一个方法的具体描述于计算流程}

例子：

public / / 修饰符 class / /类的关键字  Hello / / 类名 { //一个类的主要内容
    public  //修饰词  static void  //返回值  main // 方法名(String[] args / /参数) { 
                     // 方法代码方法体。
    } // 方法定义结束
}

一般定义类的名称的时候需要注意的点

类名必须以英文字母开头，后接字母，数字和下划线的组合

习惯以大写字母开头

运算符的优先级：

2.数据类型：

整数型：long : 长整型

int ：  (int i=XXXX) 运用于整数之间的运算。

浮点型运算：

float:单浮点型(float i =XXXX)    double：双浮点型(double i = XX) 

相对于整数型运算浮点型运算只能进行加减乘除这些数值计算，不能做位运算和移位运算。  

Boolean： 布尔类型    

3.java的流程控制 :

Java的流程控制大致分为：

(1). if else语句：无循环只进行判断。

else（一般指的是除if 外的其他可能性）

else if（在if语句中在创立一个可能性）

例子：

public class Main {
    public static void main(String[] args) {
        int n = 70;
        if (n >= 90  ) {
            System.out.println("优秀");
        } else if //在 if (n >= 90  ) 的基础上再创立一种判断(n >= 60) {
            System.out.println("及格了");
        } else {
            System.out.println("挂科了");
        }
        System.out.println("END");
    }
}

(2).for循环:

for循环是作为Java里最常用的一种循环之一，常用于数组之间的计算

例子：

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        for (int i=1//定义变量的值; i<=100//循环的极限; i++//循环的度长) {
            sum = sum + i;
        }
        System.out.println(sum);
    }
}

(3).While循环 do While 循环：

While 循环先判断循环是否符合条件在进行循环，如果不符合循环条件就会直接跳出循环进行下一个操作。而do while 循环是先进行循环计算而后在判断循环是否符合条件符合条件再进行下一个循环。

例子：while 循环

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        int n = 1;
        while (n <= 100 //如果你在开始是不符和你<=100的条件下 就会跳出循环直接输出) {
            n ++;
            sum = sum + n;
        }
        System.out.println(sum);
    }
}

do while 循环：

public class Main {
    public static void main(String[] args) {
        int sum = 0;
        int n = 1;
        do {
            sum = sum + n;
            n ++;
        } while (n <= 100); / /先进行一次计算在判断是否符合n<=100的条件在进行下一次循环
        System.out.println(sum);
    }
}
 

(4).Switch多种选择类型：

Switch一般用于多种可能性情况下进行执行的操作：、

例如商场购买打折活动，购买量超过一定的量时所达成的折扣，具有多种可能。

例子：

public class Main {
    public static void main(String[] args) {
        int option = 1;
        switch (option//定义) {
        case 1:
            System.out.println("Selected 1");
            break;
        case 2:
            System.out.println("Selected 2");
            break;
        case 3:
            System.out.println("Selected 3");
            break;

       default:   // 在定义的option中没有一个case 可以执行的情况下默认输出。

            System.out.println("Selected 4");
        }
    }
}

(5).break continue类型: 经常运用于for 循环或者while 循环中进行作用。

 break 为打破当前循环并且直接输出值，

continue 为完成当前循环，在continue下的循环不运行，直接跳到continue上的循环继续。

二.Java的面向对象：

public class +类名{

}

类当中一般包含了类的属性与类的方法，类的方发又分为 构造方法和一般方法，

构造方法与一般方法的区别在于构造方法的没有返回值，构造方法的方法名与类名相同。

调用构造方法可以是：

类的名称+ 变量名 = new 类的名称(为你所需要定义的变量)

运用Java的特性，在构造方法中定义变量后 选择Generate[生成中  Getter(获取) Setter() Constructor(构造器来直接生成所需要代码)]中的方法直接生成代码

在多个定义的变量（属性）如果没有一次定义所有变量时，可以使用 

变量名+ set变量(); 来获取数据

Java的三大特性：

1.封装(Encapsulation) ：封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

Public ：公开  private：显示类是私有的，子类不能继承。project(保护类的内容)：子类可继承

2.继承(inheritance)：子类与父类的关系，一个子类只能有一个父类，但一个父类可以有很多和子类（一对多但是不能多对一），子类可以引用父类的构造方法，但是不能继承父类的构造方法。子类不能继承（获取）父类的 private 和 project类里的数据。

继承的强大性：子类可以运用父类的所有功能，类似  Animal 是父类，中包含了动物的所有习性与特征， 子类 Cat 就可以引用父类Animal的所有功能，并且可以开发更多的功能。

3.多态(polymorphism)：表示为父类里面构造可以有多种同方法名的方法，子类可以引用父类的方法进行运行和修改(子类不能继承父类的构造方法只能引用) 打印机可以有彩色与黑白打印，我们需要那种打印技术是就可以运用哪种方法。

多态实现的方法：继承（必须继承才可以形成多态） 重写（继承父类方法直接重写） 父类引用指向子类对象 ：（名词字面意思，例如父类Animal,子类Cat,Person,Cat和Person是继承或实现Animal的子类。 Animal p = new Person(); 即声明的是父类,实际指向的是子类的一个对象。父类展示出方法，怎么运行就是子类的事情）

类与对象之间的关系是抽象的，创建对象的三个步骤为1.创建一个类（有类才可以）2.运用构造方法让对象初始化。3.与对象产生联系。

重写（Override）：在继承关系中，子类如果定义了一个与父类方法签名完全相同的方法，被称为覆写，

重载（Overload）：和继承没有关系。方法名相同但是参数不同（个数不同，类型不同，顺序不同）。

构造器/构造方法（Constrctor）：一般作用类中初始化对象的方法。一般分为有参与无参的构造器 要点：1.方法名与类名相同在方法名 2.前面没有返回值在方法中不能使用return语句返回一个值，但是可以单独写return语句来作为方法的结束

Getter（获取）：

Setter（输出）：

一.抽象类与接口（了解就好）

1.抽象类（abstract（关键词） class Person）本身被设计成只能用于被继承，因此，抽象类可以强迫子类实现其定义的抽象方法，否则编译会报错，抽象类一般在调用代码时若是有就必须使用。而非抽象类却可以不使用，他就一直纯在与的类中，（类似于object中自带的方法 equals等）抽象类更像是高层往下传递的信息流程，更注重于规则规范。

接口搞不懂

抽象方法本质上是定义接口规范：即规定高层类的接口，从而保证所有子类都有相同的接口实现，

二.静态字段于静态方法

用static修饰的字段，称为静态字段：static field， 静态字段只有一个共享空间，所有对象实例都可以调用这个字段，但其他字段每一个都有一个自己的独立空间。

用static修饰的方法就是静态方法，调用静态方法不需要实例变量，通过类名就可以实现调用，

 三:包 作用域 内部类

包含这许多类，类中包含许多定义，方法。

包没有父子关系。包于包之间只能是不同的包，两者没有任何继承关系。

内部类：一个大类中可以有很多小类。

作用域：修饰符决定类的被访问方式 public private project 

局部变量：就是在函数内部定义的变量。这个变量只能在定义这个变量的函数内部使用。函数外不能使用函数内部定义的变量 

全局变量：就是在函数外部定义的变量。（注意是定义在所有函数的外部）。所有的函数内部都可以使用这个变量。

包装类型：

定义好一个有对应的引用类型的类与其相对应的基本类型的词进行互相转换（Integer与int之间的转换）

包装类型不能继承，因为定义一个Float 类型的类时，去继承（extends）时会发现，他的父类Float被final修饰，所以不能继承。