小笔记。。。

打开CMD的方式

1.开始+系统+命令提示符

2.Win键+R键输入cmd打开控制台（推荐使用）

3.在任意的文件夹下面，按住shift键+鼠标右击，在此处打开命令

4.资源管理器的地址栏前面加上cmd路径

常用的Dos命令

#盘符切换        cd/d D:
#查看当前目录下的所有文件      dir
#切换目录      cd change directory
#返回上一级    cd..
#清理屏幕      cls(clesr screen)
#退出终端      exit
#查看电脑的ip  ipconfig
#打开应用 
#ping 命令
ping www.baidu.com
#文件操作命令
创建一个文件(目录)  md 目录名  
移除一个文件（目录）rd 目录名
在文件夹里创建文件  cd> 文件名
在文件夹里删除文件  del 文件名
#创建文件夹（目录）    md    test     cd test 进入此文件夹  cd>a.txt 在此文件夹中建立文件  del a.txt 删除这个文件
#删除目录        rd
#JAVA生成文档    javadoc    文档中如果会有中文出现  javadoc -encoding UTF-8 -charsat UTF-8 Doc.java //加这些参数是为了使文章更好看，不至于出现一些乱码

 

卸载JDK

1.删除java的安装目录

2.删除java-home

3.删除path下关于Java的目录

4.Dos命令 查看Java-version

安装JDK

1.百度搜索JDK8

2.同意协议

3.下载电脑对应的版本

4.双击安装

5.记住安装路径

6.配置环境变量

1.我的电脑-->右键-->属性

2.环境变量-->java_home

7.测试JDK是否安装成功

1.打开cmd

2.java -version

Hello World

1.随便新建一个文件夹，存放代码

2.新建一个Java文件

（1）文件后缀名为.java

（2）Hello.java

（3）系统可能没有显示文件后缀名，我们需要手动打开

3.编写代码

public class Hello{
	public static void main(String[] args){
		System.out.print("Hello,World!");
		

	}

}

4.编译javac java文件，会生成一个class文件

5.运行class文件，java class文件

 

数据类型

强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义才能使用。弱类型语言:

Java的数据类型分为两大类:基本类型和引用类型

什么是字节：

位（bit）：是计算机内部储存的最小单位，11001100是一个八位二进制数。

字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B也表示，1B（byte，字节）=8bit（位）。

字符：是指计算机中使用的字母、数字、字和符号

基本类型

//八大基本数据类型
 //整数
int num1=10;//最常用
byte num2=20;
short num3=30;
long num4=30L;//Long类型要在数字后面加个L
//小数：浮点数
float num5=50.1F;
double num6=3.1415926;
//字符
char name='A';
//字符串，String不是关键字，是一个类
String namea="小任";
//布尔值 代表是非
boolean flag=true;
//boolean flag=false;

public class Demo03 {
    public static void main(String[] args) {
         //整数拓展   进制  二进制0b  十进制  八进制0  十六进制ox
        int i=10;
        int i2=010;//八进制0
        int i3=0x10;//十六进制0x  0~9 A~F

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        //----------------------------------------------------------
        //浮点数拓展   银行业务怎么表示
        //BigDecimal  数学工具类
        //----------------------------------------------------------
        //float
        //double
        //最好完全避免使用浮点数进行比较
        float f=0.1f;
        double d=1.0/10;

        System.out.println(f==d);//false
        float d1=2131313131313131f;
        float d2=d1+1;
        System.out.println(d1==d2);//true
        //-----------------------------------------------------------------------
        //字符拓展
        //-----------------------------------------------------------------------
        char c1='a';
        char c2='中';
        System.out.println(c1);
        System.out.println((int)c1);//强制转换
        System.out.println(c2);
        System.out.println((int)c2);//强制转换
        //所有的字符本质还是数字
        //编码 Unicode表：(97 = a  65 = A)2字节  0-65536  Excel 2 16 = 65536
        //U0000 UFFFF
        char c3='\u0061';
        System.out.println(c3);//a

        //转义字符
        // \t制表符
        // \n换行
        // .......
        System.out.println("hello\tworld");
        //布尔值扩展
        boolean flag=true;
        if(flag==true){}
        if(flag){}

    }
}

类型转换

public static void main(String[] args) {
    int i=128;
    byte b=(byte)i;
    //强制转换（类型）变量名  高--低
    //自动转换   低--高
    System.out.println(i);
    System.out.println(b);
    /*注意点：
    1.不能对布尔值进行转换
    2.不能把对象类型转换为不相干的类型
    3.在把高容量转换到低容量的时候，强制转换
    4.转换的时候可能存在内存溢出，或者精度问题！
     */

 

变量：

就是可以变化的量

Java是一种强类型语言，每个变量都必须声明其类型。

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

public class Demo05  {
    public static void main(String[] args) {
        int a=1;
        int b=2;
        int c=3;
        String name ="xiaoren";
        char x='X';
        double pi=3.14;
    }
}

变量作用域：

类变量
实例变量
局部变量

public class Demo06 {
    //类变量 static
    static  double salary=2500;//目前阶段，类变量前都去加上static,这样比较好调用
    // 属性：变量
    //实例变量：从属于对象；如果不自行初始化，这个类型的默认值0 0.0
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null；
    String name;
    int age;
    //main方法
    public static void main(String[] args) {
        //局部变量；必须声明和初始化值
        int i=10;
        System.out.println(i);

        //变量类型 变量名字=new Demo06();
        Demo06 demo06=new Demo06();
        System.out.println(demo06.age);
        System.out.println(demo06.name);

        //类变量 static
        System.out.println(salary);

    }
}

常量

final 常量名=值；

final double PI=3.14；

常量名一般用大写字符

operator

package operator;
public class Demo01 {
    public static void main(String[] args) {
        int a=3;
        int b=a++;//执行完这行代码后，先给b赋值，再自增
        //a=a+1
        System.out.println(a);
        //a++  a=a+1
        int c=++a;//执行完这行代码前，先自增，再给c赋值
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        /*
        A=0011 1100
        B=0000 1101

        A&B = 0000 1100  //A与B上下对应的数字相乘
        A/B = 0011 1101  //A与B上下有一个为1，最终就为1，
        A^B = 0011 0001  //A与B上下相同为0，不同为1
        ~B  = 1111 0010  //B取反，

        2*8=16   2*2*2*2
        <<  左移 相当与 *2
        >>  右移 相当于 /2
        0000 0000    0
        0000 0001    1
        0000 0010    2
        0000 0011    3
        0000 0100    4
        0000 1000    8
        0001 0000    16
         */
        System.out.println(2<<3);
    }
}

 

package operator;

public class Demo02 {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        a+=b;//a=a+b
        a-=b;//a=a-b
        System.out.println(a);
        //字符串连接符  +   ， 在加号运算符两侧只要出现String（字符串）类型，
        // 它就会把另外一个操作数或其他操作数也转换成String类型，再进行一个连接
        //所以 （“”+a+b）会出现1020的情况
        System.out.println(""+a+b);//如果这个字符串在前面，会进行一个转换拼接
        System.out.println(a+b+"");//如果这个字符串在后面，前面会依旧进行一个计算

    }
}

 

package operator;
//三元运算符
public class Demo02 {
    public static void main(String[] args) {
        //x?y:z
        //如果x==true,则结果为y,否则结果为z
        int score =50;
        String type =score<60?"不及格":"及格";
        //if(类似于if语句)
        System.out.println(type);

    }
}

 

包机制

定义包：package

包名倒置写：com.ren.xxx

导入包：import

不想一个一个导入的话: import com.ren.base.* (星号是通配符，表示会把这个包下所有的类都导入进来)

新版idea ，右击文件 open in------>Explorer 打开文件夹，在文件夹上方的路径前加上 cmd 打开黑窗口

Scanner 对象

之前我们学的基本语法中我们并没有实现程序和人的交互，但是JAVA给我们提供了这样一个工具类，我们可以获取用户的输入。我们可以通过Scanner类来获取用户的输入

基本语法：

 

Scanner s=new Scanner(System.in);

 

package com.ren.scanner;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接受键盘数据
        //new Scanner(System.in)   //alt+enter 补全,就会出现下面一行
        Scanner scanner = new Scanner(System.in);//用于接收对象
        System.out.println("使用next方式接收：");    //这里的next还可以换做nextLine
        //判断用户有没有输入字符串
        if(scanner.hasNext()){                    //这里的hasNext换做hasNextLine
            //使用next方式接收
            String str=scanner.next();//程序会等待用户输入完毕  //这里的hasNext换做hasNextLine
            System.out.println("输出的内容为："+str);
        }
        scanner.close();//凡是属于IO流（输入输出流）的类如果不关闭会一直占用资源，要养成好习惯用完就关掉

    }
}

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

next（）：

1.一定要读取到有效字符才可以结束输入

2.对输入有效字符之前遇到的空白，next（）方法会自动将其去掉

3.只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符

4.next()不能得到带有空格的字符串

nextLine()：

1.以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符

2.可以获得空白

package com.ren.scanner;
import java.util.Scanner;
//万一要输入int或小数，在scanner中也有支持
public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        //从键盘接收数据
        int i=0;
        float f=0.0f;


        System.out.println("请输入整数：");
        if(scanner.hasNextInt()){
            i = scanner.nextInt();
            System.out.println("整数数据："+i);
        }else{
            System.out.println("输入的人不是整数数据！");
        }

        System.out.println("请输入小数：");
        if(scanner.hasNextFloat()){
            f = scanner.nextInt();
            System.out.println("小数数据："+f);
        }else{
            System.out.println("输入的人不是小数数据！");
        }
        scanner.close();
    }
}

案例：

package com.ren.scanner;
import java.util.Scanner;
public class Demo03 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果
        Scanner scanner = new Scanner(System.in);
        //和
        double sum=0;
        //计算输入了多少个数字
        int m=0;
        //通过循环判断是否还有输入，并在里面对每一次进行求和统计
        while(scanner.hasNextDouble()){
            double x= scanner.nextDouble();
            m=m+1;
            sum=sum+x;
            System.out.println("你输入了第"+m+"个数据，然后当前结果sum="+sum);
        }
        System.out.println(m+"个数的和为："+sum);
        System.out.println(m+"个数的平均值是："+(sum/m));
        
        scanner.close();
    }
}

顺序结构

package com.ren.struct;
//java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行
public class Demo01 {
    public static void main(String[] args) {
        System.out.println("hello1");
        System.out.println("hello2");
        System.out.println("hello3");
        System.out.println("hello4");
        System.out.println("hello5 ");
    }
}

顺序结构是最简单的算法结构

语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构

选择结构

if单选择结构

package com.ren.struct;
import java.util.Scanner;
public class ifDemo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);//输入new Scanner(System.in),按住alt+enter进行补全
        System.out.println("请输入内容：");
        String s = scanner.nextLine(); //输入scanner.nextLine,按住alt+enter进行补全。将其保存在s中
                                       //用nextLine是因为用户可能会输入中文或空格
        //equals:用于判断字符串是否相等
        if(s.equals("hello")) {       //如果字符串等于hello
            System.out.println(s);    //就输出s
        }
        System.out.println("End");    //否则输出End
        scanner.close();
    }
}

 

if双选择结构

package com.ren.struct;
import java.util.Scanner;
public class ifDemo02 {
    public static void main(String[] args) {
        //考试分数大于60就是及格，小于60分就是不及格
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();//等待用户的输入
        if(score>60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        scanner.close();
    }
}

 

if多选择结构

package com.ren.struct;
import java.util.Scanner;
public class ifDemo03 {
    public static void main(String[] args) {
        //考试分数大于60就是及格，小于60分就是不及格
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = scanner.nextInt();//等待用户的输入
        if(score==100){
            System.out.println("恭喜满分");
        }else if(score<100&&score>=90){
            System.out.println("A");
        }else if(score<90&&score>=80){
            System.out.println("B");
        }else if(score>100){
            System.out.println("成绩不合法");
        }
        scanner.close();
    }
}

 

嵌套的if结构

switch多选择结构

package com.ren.struct;
public class switchDemo04 {
    public static void main(String[] args) {
        char grade='C';
        switch (grade){
            case'A':
                System.out.println("优秀");
                break;
            case'B':
                System.out.println("良好");
            case'C':
                System.out.println("及格");
            case'D':
                System.out.println("挂科");
            default:
                System.out.println("未知等级")
        }
    }
}

 

break，否则就会把下面的都输出

switch语句中的变量类型可以是：

byte , short , int , char / 从JavaSE开始，switch支持字符串String类型了 / case标签必须为字符串常量或字面量

while循环

在java5引入了一种主要用于数组的增强型for循环

//while循环
package com.ren.struct;
public class whileDemo01 {
    public static void main(String[] args){
        //输出1~100
        int i=0;
        while(i<100){
            i++;
            System.out.println(i);
        }
    }
}

package com.ren.struct;
public class whileDemo01 {
    public static void main(String[] args) {
        //计算1+2+3+....+100
        int i=0;
        int sum=0;
        while(i<=100){
            sum=sum+i;
            i++;
        }
        System.out.println(sum);
    }
}

do...while与while的区别

while先判断后执行。dowhile是先执行后判断

do...while总是保证循环体会被至少执行一次

do...while循环

package com.ren.struct;
public class whileDemo01 {
    public static void main(String[] args) {
        //计算1+2+3+....+100
        int i=0;
        int sum=0;
        do{
            sum=sum+i;
        }while (i<=100);
        System.out.println(sum);
    }
}

package com.ren.struct;
public class whileDemo01 {
    public static void main(String[] args) {
        int a=0;
        while(a<0){
            System.out.println(a);
            a++;
        }
        System.out.println("========================");
        do{
            System.out.println(a);
            a++;
        }while(a<0);
    }
}

 

只出现了分割线下面的一个0，是因为do...while至少要被执行一次，上面的while部分a=0没有满足a<0直接跳过了

for循环

for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构

package com.ren.struct;
public class forDemo01 {
    public static void main(String[] args) {
        int a=1;  //初始化条件
        while(a<=100){    //条件判断
            System.out.println(a);//循环体
            a+=2;//迭代
        }
        System.out.println("while循环结束");

        //初始化//条件判断//迭代
        for(int i=1;i<=100;i++){
            System.out.println(i);
        }
        System.out.println("for循环结束");
    }
}

 

package com.ren.struct;
public class forDemo02 {
    public static void main(String[] args) {
        //练习1：计算0~100之间的奇数和偶数的和
        int oddSum=0;  //保存奇数的和
        int evenSum=0; //保存偶数的和
        for(int i=0;i<100;i++)
        {
            if(i%2!=0)
            {
                oddSum+=i;
            }else
            {
                evenSum+=i;
            }
        }
        System.out.println("奇数的和："+oddSum);
        System.out.println("偶数的和："+evenSum);
    }
}

package com.ren.struct;
public class forDemo03 {
    public static void main(String[] args) {
        //练习2：用while或for循环输出1~1000之间能被5整除的数，并且每行输出3个
        for (int i=0;i<=1000;i++){
            if(i%5==0){
                System.out.print(i+"\t");
            }
            if(i%(5*3)==0){
                System.out.println();
                //System.out.println("\n");
            }
        }
        //println:输出完会换行，print:输出完不会换行
    }
}

package com.ren.struct;
public class forDemo05 {
    public static void main(String[] args) {
        int[]numbers={10,20,30,40,50};//定义了一个数组
        for(int i=0;i<5;i++){
            System.out.println(numbers[i]);
        }
        System.out.println("========================");
        //遍历数组的元素
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

 

break与continue

break用于强行退出循环，不执行循环语句中剩余的语句（break语句也在switch语句中使用）

package com.ren.struct;
public class breakDemo {
    public static void main(String[] args) {
        int i=0;
        while(i<100){
            i++;
            System.out.println(i);
            if(i==30){
                break;
            }
        }
        System.out.println("123");
    }
}

 continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定

package com.ren.struct;
public class breakDemo {
    public static void main(String[] args) {
        int i=0;
        while(i<100){
            i++;
            System.out.println(i);
            if(i==30){
                break;
            }
        }
        System.out.println("123");
    }
}

package com.ren.struct;
//练习：打印三角形
public class textDemo01 {
    public static void main(String[] args) {
       for(int i=1;i<=5;i++){
           for(int j=5;j>=i;j--){
               System.out.print(" ");
           }
           for(int j=1;j<=i;j++){
               System.out.print("*");
           }
           for(int j=1;j<i;j++){
               System.out.print("*");
           }
           System.out.println();
       }
    }
}

 

Java学习的方法

System.out.println()

前面几章使用到的System.out.println()，它是什么？

println()是一个方法。 System是系统类。 out是标准输出对象。

这句话的意思是调用系统类System中的标准输出对象out中的方法println()。

什么是方法？

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

方法包含于类或对象中。

方法在程序中被创建，在其他地方被引用。

方法的优点

使程序变得简短而清晰。

有利于程序维护。

可以提高程序开发的效率。

提高了代码的重用性。

方法的命名规则

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

2.下划线可能出现在JUnit测试方法名称中用分隔名称的逻辑组件。一个典型的模式是：test<MethodUnderTest>_<state>, 例如 ：testPop_emptyStack。

方法的定义

一般情况下，定义一个方法包含以下语法：

修饰符  返回值类型  方法名（参数类型  参数名）{
...
方法体
...
return 返回值
}

 

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

**修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

**返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void。

**方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

**参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

**方法体：方法体包含具体的语句、定义该方法的功能。

如：

public static int age(int birthday){...}

 参数可以有多个：

static float interest(float principal,int year){...}

 

注意：在其他一些语言中方法指 过程和函数。一个返回非void类型返回值的方法称为函数；一个返回void类型返回值的方法叫做过程。

实例

下面的方法包含2个参数num1和num2，它返回这两个参数的最大值。

/**返回两个整型变量数据的较大值 */
public static int max(int num1,int num2){
int result;
if(num1>num2)
result=num1;
else
result=num2;
return result;
}

 更简略的写法（三元运算符）：

public static int max(int num1,int num2){
return num1>num2?num1:num2;
}

 

方法的调用

Java支持两种调用方法的方式，根据方法是否返回值来选择。

当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int larger=max(30,40);

 如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。下面的调用是个语句：

System.out.println("欢迎访问");

 实例

public class TestMax{
//主方法
public static void main(String[ ] args){
int i=5;
int j=2;
int k=max(i , j);
System.out.println(i+"和"+j+"比较，最大值是："+k);
}

//返回两个整数变量较大的值
public static int max(int num1,int num2){
int result;
if(num1>num2)
result=num1;
else
result=num2;
return result;
}
}

 这个程序包含main方法和max方法。main方法是被JVM调用的，除此之外，main方法和其他方法没什么区别。main方法的头部是不变的，如例子所示，带修饰符public和static，返回void类型值，方法名字是main，此外带一个String[ ]类型参数。String[ ]表明参数是字符串数组。

package com.ren.method;
public class Demo02 {
    public static void main(String[] args) {
        int max = max(10, 20);
        System.out.println(max);
    }
    //比大小
    public static int max(int num1,int num2){
        int result;
        if(num1==num2){
            System.out.println("num1==num2");
            return 0;//return 除了返回结果的意思还有终止方法的意思
        }
        if(num1>num2){
            result=num1;
        }else{
            result=num2;
        }
        return result;
    }
}

 

void关键字

本节说明如何声明和调用一个void方法。

下面的例子声明了一个名为printGrade的方法，并调用它来打印给定的分数。

 public static void main(String[ ] args){
            printGrade(78.5);
        }
        public static void printGrade(double score){
            if(score>=90.0){
                System.out.println('A');
            }
            else if(score>=80.0){
                System.out.println('B');
            }
            else if(score>=70.0){
                System.out.println('C');
            }
            else if(score>=60){
                System.out.println('D');
            }
            else{
                System.out.println('F');
            }
        }
    }

 

这里的printGrade方法是一个void类型的方法，它不返回值。一个void方法的调用一定是一个语句。所以，它在被main方法第三行以语句形式调用。就像任何分号结束的语句一样。

通过值传递参数

调用一个方法时候需要提供参数，你必须按照参数列表指定的顺序提供。

例如：下面的方法连续n次打印一个消息：

public static void nPrintln(String message,int n){
for (int i=0;i<n;i++){
System.out.println(message);
   }
}

 下面的例子演示按值传递的效果。该程序创建一个方法，该方法用于交换两个变量。

package com.ren.method;
public class nnn {
    public static void main(String[] args) {
        int num1=1;
        int num2=2;
        System.out.println("交换前num1的值为："+num1+"num2的值为："+num2);
        //调用swap方法
        swap(num1,num2);
        System.out.println("交换后num1的值为："+num1+"，num2的值为："+num2);
    }
        public static void swap(int n1,int n2){
            System.out.println("\t进入swap方法");
            System.out.println("\t\t交换前n1的值为："+n1+",n2的值为："+n2);
            //交换n1与n2的值
            int temp=n1;
            n1=n2;
            n2=temp;
            System.out.println("\t\t交换后n1的值为"+ n1 +"，n2的值为："+n2);
        }
    }
}

 

传递两个参数调用swap方法。方法被调用后，实参的值并没有改变。

方法重载

上面使用的max方法仅仅适用于int型数据。但如果你想得到两个浮点类型数据的最大值呢？

解决方法是创建另一个有相同名字但参数不同的方法，如下面代码所示：

public static double max(double num1,double num2){
    if(num1>num2)
        return num1;
    else
        return num2;
}

 

如果你调用max方法时传递的是in型参数，则int型参数的max方法就会被调用；如果传递的是double型参数，则double类型的max方法体会被调用，这叫做方法重载；就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。Java编译器根据方法签名判断哪个方法应该被调用。方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。

变量作用域

变量的范围是程序中该变量可以被引用的部分。

方法内定义的变量被称为局部变量。

局部变量的作用范围从声明开始，直到包含它的块结束。

局部变量必须声明才可以使用。

方法的参数范围涵盖整个方法。参数实际上是一个局部变量。

for循环的初始化部分声明的变量，其作用范围在整个循环。但循环体内

 

命令行参数的使用

有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main（）函数实现。命令行参数是在执行程序的时候紧跟在程序名字后面的信息。

package com.ren.method;
public class nnn {
    public static void main(String[] args) {
        for(int i=0;i<args.length;i++){
            System.out.println("args[" + i + "]:"+ args[i]);
        }
    }
}

### 构造方法

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

## 面向对象

### 什么是面向对象？

面向对象编程（Object-Oriented Programming,OOP）的本质是：以类的方式组织代码，以对象的组织（封装）数据。

 

三大特性：封装、继承、多态

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。

从代码运行角度考虑是先有类后有对象。类是对象的模板。

回顾方法及加深

方法的定义

修饰符

返回类型

break和return的区别

方法名

参数列表

异常抛出

方法的调用

静态方法

非静态方法

形参和实参

值传递和引用传递

this关键字

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一具体的事物。