Day1
1.创始人 詹姆斯·高斯林（sun）

2.1.2 版本有3个平台 J2SE（桌面开发  基础） J2ME（移动嵌入式开发 驱动）  J2EE（网页开发）

3.DOS命令
d: 盘符切换

dir 当前目录下所有文件夹名称

cd 进入某一个目录

cd..  回退文件夹

cd 文件夹名臣\\跟文件夹名称 回车 多级进入    （"复制粘贴"）

cd/回车 多级回退

cls：清屏

md 创建

exit： 退出

.当前路径
..上一级路径

4.jdk环境   jvm 虚拟机

JRE运行程序 包含JVM
JDK开发工具 包含JRE核心类库 包含JVM

jave特性:开源  跨平台

5.首先定义一个类名 要求和文件名同名

main 主方法 程序运行 从主方法开始

打开命令符输入JAVAC 文件名.java 编译 生成JAVA.CLASS文件
输入java 文件名 输出

6.非法字符 中文符号出现

7./** */文档注释

8.组成关键字的字母全部小写
  常见的代码编辑器对关键字有特殊的颜色标记

9.标识符：起名字 /除了关键字的单词 全部都是标识符
  标识符可以自己定义

10.常量
  在程序的执行过程中，其值不可以发生改变的量
  分类
  1.字符串 ""
  2.整数
  3.小数
  4.字符常量   ''
  5.布尔常量 TURE  FALSE
  6.空常量   NULL

11. 变量
  是内存中的一小块区域，在程序执行过程中，其值可以在一定范围内发生改变
  1.对区域要有限定
        有数据类型来限定
  2.必须对区域给一个名称
           变量名
  3.区域内必须有内容
        初始化值
   格式：数据类型  变量名 = 初始化值；

12.1b =8bit    00000001
   1kb=1024b
   1mb =1024kb
   ..
   1tb=1024gb
  最小信息单元 bit
  最小存储单元 byte

13.数据类型分类：
   基本数据类型  4类8种
   整数 byte 1    -127~128
        short 2
        int 4
        long 8
   浮点
       float  4  单精度
       double 8

   字符 char 2

   布尔   1        大小没有定义
      byte<short<int<long<float<double

   引用数据类型（类，接口，数组）
   string 引用数据类

整数默认时int,浮点数是DOUBLE
定义long 要加L 和l 建议加10000000000L
定义float 要加F   12.34F



14.标识符 给包，类，方法变量等起名字的符号
  规则:数字字符，英文大小写字母，以及汉字（不建议）
  还可以由_和$组成
  注意：不能由数字开头
        不能是关键字

15.变量定义的注意事项
   局部变量未赋值不能直接使用
   变量只在它所属的范围内有效
   变量属于它所在的那对大括号
   一行可以定义多个变量，但是不建议
   同范一围内，不能重复定义相同名字的变量

16.类名，接口名  首字母大写，如果包含多个单词，后续单词每个首字母大写
  方法名，变量名    首字母小写 后续单词 每个首字母大写
  常量名 所有字母都大写，包含多个单词 单词之间用_链接

17. byte<short<int<long<float<double
   隐式转换：从小到大自动就能提升为大的类型
**隐式转  整数转换默认为INT

18.强制转化
   例子byte = b(a + b);
   目标类型 变量名 = （目标类型）（被转换的数据）;

Day2
辅助建        main方法
        main alt+/
        syso alt+/
快捷键        注释
        单行选中内容 ctrl+/
        多行 ctrl+shift+/,取消选中ctrl+shift+\
格式化
        ctrl+shfit+f
        右键 source format

运算符
        /整数相除得到整数，得到小数加上小数点
        %获取两个数据的余数
        /获取两个数据的商

字符和字符参加运算
        ++放在字母前面 先自增在赋值
          放在字母后面，先赋值在自增（--同理）
          单独使用自增，自减

字符参与加法云散，其实是拿字符在计算机中存的数据值来参加运算
        'A'= 65   a-z顺序加1
        'a'= 97
        '0'= 48   同理
字符和int值相加：字符会变成值再去加。

00000011    二进制
----8421 = 3

扩展的赋值运算符，隐含强制类型转换

关系运算符计算出来的结果。都是boolean类型的

&有FALSE则FALSE  &&  左边有false执行左边 右边不执行  
|有true则true         ||  左边有true执行左边 右边不执行
^ 结果相同为false不同为ture
！，ture则false,false则true

三元运算符
关系表达式？表达式1：表达式2
true 表达式1是结果；false表达式2就是结果

Scanner
import java.util.Scanner;
在一个类中。package>import>class
创建键盘录入对象
Scanner sc = new Scanner(System.in);
接受数据
int i = sc.nextInt();

Day3
选择结构
  If语句
  swich

格式：
            变量定义；
        if(关系表达式 布尔类型false不运行){ 语句体； }

int 变量键盘录入快捷键
   ctrl+1+enter

格式2
        if(){
                语句体1；
        }else{
                语句体2；
        }

格式3
        if(){
        }else if(){
        }else{
        }
注意：当条件都满足，运行从上往下，只执行第一个
导包快捷键 ctrl+shift+o

格式：
switch(表达式){
        case 值1:语句体1；
        break;
        case  值 2:语句体2；
        break;
        .....
        default:语句体N;
        break;
        }

表达式：byte,short,int,char
case后面的值，就是用来和表达式值进行匹配的内容
break:中断的意思
default:所有的值都不匹配的时候，就执行

循环语句
格式：for(初始化语句；判断条件语句；控制条件语句){
                循环体语句；          
        }
false结束循环，ture继续执行

运行流程：1初始化 2 判断条件 3执行循环 4执行控制 5回到2

格式：
        while(判断条件语句){循环体语句;
                           }
       
        初始化语句;    可以使用
        while(判断条件语句){
                            循环体语句;
                            控制条件语句;
                           }
格式
        do{
             循环体语句;
        }while(判断语句);

        初始化语句;    可以使用
        do{
            循环体语句;
            控制条件语句;       
           }while（判断条件语句）;

        执行初始化
        执行循环体
        执行控制条件
        执行判断条件，false结束循环，true继续循环.

do..whlie不管条件慢不慢足至少执行一次循环体
for,while循环必须判断条件成立才可以执行
for循环当初语句始化放在外面时，变量可以继续访问


推荐使用：for---while---do...while

死循环
for(;true;){ 语句体;}
while(true){ 语句体;}
do()while(true);

Break
    在switch语句中，循环语句中使用
    在离开使用场景里是没有意义的

contiune用在循环中
        满足条件是终止本次，继续循环

switch 选择中 先运行CASE 在运行defult 如果没有break 自动往下运行
        叫做CASE穿透,知道遇到最后一个大括号

Day 4
Random 随机数
        1.导包.import java.util.Random;
          2.输入 Random r = new Random(); 创建对象
        3.int number= r.nextInt(10);    获取随机数[0,100)
          int number=r.nextInt(41)+25;
       
数组：存储同一种数据类型的多个元素的容器   引用类型
变量：只能存一个元素的容器
集合：存很多长度不固定

定义格式
     数据类型[]数组名；
     数据类型 数组名[]；

数组初始化
     就是为数组开辟内存空间并为数组中的每个元素赋予初始值
     动态初始化    只给出长度 系统给出初始化值
     静态初始化   给出初始化值，由系统决定长度     

     动态初始化
     数据类型[] 数组名 = new 数据类型[数组长度];     
     int[] arr = new int[5];
     栈内存         堆内存

     赋值
     arr[0]= 5;

     通过数组名和数组编号获取元素值（数组最大编号=数组最大长度-1）
     system.out.println(arr[0]);

     整数的 初始化 0
     浮点型 0.0
     布尔型 false
     字符型 '/u0000' 空字符
     引用类型 null

     栈（存储的是局部变量）定义在方法中的变量
     堆（new出来的东西） 实体，对象，一个地址值，每一个对象的数据都有一个默认值

     int[] arr2 =arr;  赋值第二个数组地址值

     静态数组
     int[]arr={1,2,3};   简化格式
     静态数组的初始化值
     数据类型[]  数组名= new 数据类型[]{元素1，元素2....}；

     引用类型：类，接口，数组
     常量：空常量,null，是可以赋值给引用类型
           赋值空地址，会长生空指针异常

     数组的遍历，获取数组的每一个元素 并可以赋值
     ctrl+alt+↓快捷键

     用循环做遍历

二维数组
     数据类型[][]数组名；
     数据类型 数组名[][]；
     数据类型[]数组名[]；

     int[][]数组名=new 数据类型[][]；  动态数组的定义格式
     int[][]arr ={{1,2,3},{2,3},{3,4,5}} ;   静态数组定义格式
        arr[0][1]=100;

Day 5
方法的定义：
        完成特定功能的代码块

格式                             （参数列表类型可以不同）
        修饰符 返回值类型 方法名（参数类型  参数名1，参数类型 参数名2）{
        方法体;
        rerturn 返回值;
        }       

        返回值类型：用于限定返回值的数据类型
        方法名：取名字
        参数类型：用于限定 调用方法时 传入数据的类型
        参数名：接受数据的变量
        方法体：完成功能的代码
        return 结束方法，返回值给调用者

写方法时必须明确 返回值类型  参数列表

sum(a,b,c);    //1.单独调用，赋值,但不能输出
System.out.println(sum(a,b,c));   //2.输出调用,但不能变更使用使用
int result =sum(a,b,c);//在次赋值调用，并操作

注意事项：
        1.方法不能嵌套

void修饰的方法只能单独调用

main方法中如果定义了变量，变量会赋值给下面的方法中的变量中，
如果没有赋值，在新定义方法上没有写出参数类型和数据，需要在方法体中定义变量
main方法上直接调用

方法的重载
        定义：方法名相同，参数列表不同，与返回值无关
        2.参数对应的数据类型不同
        3.参数个数不同

不能出现方法名相同，并且参数列表页相同的情况
println()就是方法重载

方法的参数如果是基本数据类型：形式参数的改变不影响实际参数。

形式参数：用于接受实际参数的变量
实际参数：实际参与运算的变量

栈：执行方法
堆：存储一些引用型数据的
方法去：存储一些CLASS文件的
本地方法区：存储一些本地方法的
寄存器：cpu

如果参数是引用数据类型：
        形式参数的改变直接影响实际参数
system.out.println(Arrays.toStingt(arr));
打印并遍历


Day6
面向对象是基于面向过程的变成思想

面向过程：强调的是每一个功能的步骤
面向对象：强调的是对象，由对象去调用功能

类:是一组相关的属性和行为的集合
对象：就是该对象的具体体现

描述一类事物的时候：定义为类

类是如何和事物进行对应
        类：成员变量
            成员方法

成员变量：和变量定义一样
        位置不同：类中，方法外
        初始化值：不需要给初始化值
       
局部变量：定义在方法里面的变量叫局部变量，必须初始化

成员方法：和方法定义一样
        去掉static

使用一个类，就是使用该类的成员（成员变量和成员方法）

格式：类名 对象名 =NEW 类名（）

访问成员
        成员变量：对象名.变量名
        成员方法：对象名.方法名（x）

在内存中位置不同
        成员变量：堆内存
        局部变量：栈内存
生命周期不同
        成员变量：随着对象的创建而存在，随着对象的消失而消失
        局部：随着方法调用而存在，随着方法调用完毕而消失

prvite
        修饰符
        可以修饰成员变量，修饰成员方法
        被修饰的的只能成员在本类中访问
针对private 提供get 和set方法用于获取成员变量的值，public修饰

面向对象：
        封装，继承，多态三个特征

        封装：把不需要对外展示的内容，隐藏起来，对外提供公共访问方式。
        好处：安全 提高代码复用性

如果有局部变量名和成员变量名相同时，在局部使用的时候，采用就近原则

构造方法
        给对象的数据进行初始化

格式
        方法名和类名相同
        没有返回值类型，void都不能写
        没有具体的返回值

调用构造方法
        格式
        类名对象名 = new 构造方法（。。。。）;
构造方法的注意事项
        如果我们给出构造方法，系统默认提供无参构造方法供我们使用
        如果给出构造方法，系统不再提供默认无参方法使用
        如果我们想使用有参构造方法，就必须自己提供无参构造
        构造方法可以重载

类名作为形式参数，其实这里就是该类对象

当返回值类型是类的时候，返回的就是该类的对象


讲了类的定义和调用

第一步
定义类 创建类

public class 类

public Student(){ 无参构造方法  public + 类名
}

定义 成员变量
String name;
private int age;     被private修饰的成员变量不能直接调用，只能本类中访问


pubilc void setAge(int a){          设置set方法为了设置成员变量的值，方法中无需返回值，但要注明赋值的类型（可以用判断条件语句进行筛选错误的信息）
        age =a;
}

public int getAge(){        设置get方法为了获取设置成员变量的后的值，有返回值，所以方法中要写出返回值类型
        return age;
}



定义 成员方法
public void (study)方法名（）{

}

第二部
创建一个主方法
public static void main(String[] args){
        创建类的对象   其实就是构造方法
        类名 对象名=new 类名（）；
        Student s =new Studen();

第三步 给成员变量赋值
        s.name ="";
        s.age=10;

第四部 调用成员方法
        s.study();

有参构造 调用方法
        Student s =new Studen(参数列表);
        s.方法名();
}

变量在使用的时候，如果局部变量和成员变量同名时，系统先就近在方法里找局部变量开始复制，这个叫就近原则，可以用this解觉，代表类中的对象引用

格式
        类名 对象名 =new 构造方法（）；
        Studeng s= new Sudent;

当第一个类中有一个方法，第二个类中调用了第一个类的方法，那么在第三个主方(test)法中必需创建第一和第二的对象，
并在主方法中调用第二个方法，传入第一个类的对象
Teach t =new Teach();
Student s=new Student();
t.test(s);

Day1
1.创始人 詹姆斯·高斯林（sun）

2.1.2 版本有3个平台 J2SE（桌面开发  基础） J2ME（移动嵌入式开发 驱动）  J2EE（网页开发）

3.DOS命令
d: 盘符切换

dir 当前目录下所有文件夹名称

cd 进入某一个目录

cd..  回退文件夹

cd 文件夹名臣\\跟文件夹名称 回车 多级进入    （"复制粘贴"）

cd/回车 多级回退

cls：清屏

md 创建

exit： 退出

.当前路径
..上一级路径

4.jdk环境   jvm 虚拟机

JRE运行程序 包含JVM
JDK开发工具 包含JRE核心类库 包含JVM

jave特性:开源  跨平台

5.首先定义一个类名 要求和文件名同名

main 主方法 程序运行 从主方法开始

打开命令符输入JAVAC 文件名.java 编译 生成JAVA.CLASS文件
输入java 文件名 输出

6.非法字符 中文符号出现

7./** */文档注释

8.组成关键字的字母全部小写
  常见的代码编辑器对关键字有特殊的颜色标记

9.标识符：起名字 /除了关键字的单词 全部都是标识符
  标识符可以自己定义

10.常量
  在程序的执行过程中，其值不可以发生改变的量
  分类
  1.字符串 ""
  2.整数
  3.小数
  4.字符常量   ''
  5.布尔常量 TURE  FALSE
  6.空常量   NULL

11. 变量
  是内存中的一小块区域，在程序执行过程中，其值可以在一定范围内发生改变
  1.对区域要有限定
        有数据类型来限定
  2.必须对区域给一个名称
           变量名
  3.区域内必须有内容
        初始化值
   格式：数据类型  变量名 = 初始化值；

12.1b =8bit    00000001
   1kb=1024b
   1mb =1024kb
   ..
   1tb=1024gb
  最小信息单元 bit
  最小存储单元 byte

13.数据类型分类：
   基本数据类型  4类8种
   整数 byte 1    -127~128
        short 2
        int 4
        long 8
   浮点
       float  4  单精度
       double 8

   字符 char 2

   布尔   1        大小没有定义
      byte<short<int<long<float<double

   引用数据类型（类，接口，数组）
   string 引用数据类

整数默认时int,浮点数是DOUBLE
定义long 要加L 和l 建议加10000000000L
定义float 要加F   12.34F



14.标识符 给包，类，方法变量等起名字的符号
  规则:数字字符，英文大小写字母，以及汉字（不建议）
  还可以由_和$组成
  注意：不能由数字开头
        不能是关键字

15.变量定义的注意事项
   局部变量未赋值不能直接使用
   变量只在它所属的范围内有效
   变量属于它所在的那对大括号
   一行可以定义多个变量，但是不建议
   同范一围内，不能重复定义相同名字的变量

16.类名，接口名  首字母大写，如果包含多个单词，后续单词每个首字母大写
  方法名，变量名    首字母小写 后续单词 每个首字母大写
  常量名 所有字母都大写，包含多个单词 单词之间用_链接

17. byte<short<int<long<float<double
   隐式转换：从小到大自动就能提升为大的类型
**隐式转  整数转换默认为INT

18.强制转化
   例子byte = b(a + b);
   目标类型 变量名 = （目标类型）（被转换的数据）;

Day2
辅助建        main方法
        main alt+/
        syso alt+/
快捷键        注释
        单行选中内容 ctrl+/
        多行 ctrl+shift+/,取消选中ctrl+shift+\
格式化
        ctrl+shfit+f
        右键 source format

运算符
        /整数相除得到整数，得到小数加上小数点
        %获取两个数据的余数
        /获取两个数据的商

字符和字符参加运算
        ++放在字母前面 先自增在赋值
          放在字母后面，先赋值在自增（--同理）
          单独使用自增，自减

字符参与加法云散，其实是拿字符在计算机中存的数据值来参加运算
        'A'= 65   a-z顺序加1
        'a'= 97
        '0'= 48   同理
字符和int值相加：字符会变成值再去加。

00000011    二进制
----8421 = 3

扩展的赋值运算符，隐含强制类型转换

关系运算符计算出来的结果。都是boolean类型的

&有FALSE则FALSE  &&  左边有false执行左边 右边不执行  
|有true则true         ||  左边有true执行左边 右边不执行
^ 结果相同为false不同为ture
！，ture则false,false则true

三元运算符
关系表达式？表达式1：表达式2
true 表达式1是结果；false表达式2就是结果

Scanner
import java.util.Scanner;
在一个类中。package>import>class
创建键盘录入对象
Scanner sc = new Scanner(System.in);
接受数据
int i = sc.nextInt();

Day3
选择结构
  If语句
  swich

格式：
            变量定义；
        if(关系表达式 布尔类型false不运行){ 语句体； }

int 变量键盘录入快捷键
   ctrl+1+enter

格式2
        if(){
                语句体1；
        }else{
                语句体2；
        }

格式3
        if(){
        }else if(){
        }else{
        }
注意：当条件都满足，运行从上往下，只执行第一个
导包快捷键 ctrl+shift+o

格式：
switch(表达式){
        case 值1:语句体1；
        break;
        case  值 2:语句体2；
        break;
        .....
        default:语句体N;
        break;
        }

表达式：byte,short,int,char
case后面的值，就是用来和表达式值进行匹配的内容
break:中断的意思
default:所有的值都不匹配的时候，就执行

循环语句
格式：for(初始化语句；判断条件语句；控制条件语句){
                循环体语句；          
        }
false结束循环，ture继续执行

运行流程：1初始化 2 判断条件 3执行循环 4执行控制 5回到2

格式：
        while(判断条件语句){循环体语句;
                           }
       
        初始化语句;    可以使用
        while(判断条件语句){
                            循环体语句;
                            控制条件语句;
                           }
格式
        do{
             循环体语句;
        }while(判断语句);

        初始化语句;    可以使用
        do{
            循环体语句;
            控制条件语句;       
           }while（判断条件语句）;

        执行初始化
        执行循环体
        执行控制条件
        执行判断条件，false结束循环，true继续循环.

do..whlie不管条件慢不慢足至少执行一次循环体
for,while循环必须判断条件成立才可以执行
for循环当初语句始化放在外面时，变量可以继续访问


推荐使用：for---while---do...while

死循环
for(;true;){ 语句体;}
while(true){ 语句体;}
do()while(true);

Break
    在switch语句中，循环语句中使用
    在离开使用场景里是没有意义的

contiune用在循环中
        满足条件是终止本次，继续循环

switch 选择中 先运行CASE 在运行defult 如果没有break 自动往下运行
        叫做CASE穿透,知道遇到最后一个大括号

Day 4
Random 随机数
        1.导包.import java.util.Random;
          2.输入 Random r = new Random(); 创建对象
        3.int number= r.nextInt(10);    获取随机数[0,100)
          int number=r.nextInt(41)+25;
       
数组：存储同一种数据类型的多个元素的容器   引用类型
变量：只能存一个元素的容器
集合：存很多长度不固定

定义格式
     数据类型[]数组名；
     数据类型 数组名[]；

数组初始化
     就是为数组开辟内存空间并为数组中的每个元素赋予初始值
     动态初始化    只给出长度 系统给出初始化值
     静态初始化   给出初始化值，由系统决定长度     

     动态初始化
     数据类型[] 数组名 = new 数据类型[数组长度];     
     int[] arr = new int[5];
     栈内存         堆内存

     赋值
     arr[0]= 5;

     通过数组名和数组编号获取元素值（数组最大编号=数组最大长度-1）
     system.out.println(arr[0]);

     整数的 初始化 0
     浮点型 0.0
     布尔型 false
     字符型 '/u0000' 空字符
     引用类型 null

     栈（存储的是局部变量）定义在方法中的变量
     堆（new出来的东西） 实体，对象，一个地址值，每一个对象的数据都有一个默认值

     int[] arr2 =arr;  赋值第二个数组地址值

     静态数组
     int[]arr={1,2,3};   简化格式
     静态数组的初始化值
     数据类型[]  数组名= new 数据类型[]{元素1，元素2....}；

     引用类型：类，接口，数组
     常量：空常量,null，是可以赋值给引用类型
           赋值空地址，会长生空指针异常

     数组的遍历，获取数组的每一个元素 并可以赋值
     ctrl+alt+↓快捷键

     用循环做遍历

二维数组
     数据类型[][]数组名；
     数据类型 数组名[][]；
     数据类型[]数组名[]；

     int[][]数组名=new 数据类型[][]；  动态数组的定义格式
     int[][]arr ={{1,2,3},{2,3},{3,4,5}} ;   静态数组定义格式
        arr[0][1]=100;

Day 5
方法的定义：
        完成特定功能的代码块

格式                             （参数列表类型可以不同）
        修饰符 返回值类型 方法名（参数类型  参数名1，参数类型 参数名2）{
        方法体;
        rerturn 返回值;
        }       

        返回值类型：用于限定返回值的数据类型
        方法名：取名字
        参数类型：用于限定 调用方法时 传入数据的类型
        参数名：接受数据的变量
        方法体：完成功能的代码
        return 结束方法，返回值给调用者

写方法时必须明确 返回值类型  参数列表

sum(a,b,c);    //1.单独调用，赋值,但不能输出
System.out.println(sum(a,b,c));   //2.输出调用,但不能变更使用使用
int result =sum(a,b,c);//在次赋值调用，并操作

注意事项：
        1.方法不能嵌套

void修饰的方法只能单独调用

main方法中如果定义了变量，变量会赋值给下面的方法中的变量中，
如果没有赋值，在新定义方法上没有写出参数类型和数据，需要在方法体中定义变量
main方法上直接调用

方法的重载
        定义：方法名相同，参数列表不同，与返回值无关
        2.参数对应的数据类型不同
        3.参数个数不同

不能出现方法名相同，并且参数列表页相同的情况
println()就是方法重载

方法的参数如果是基本数据类型：形式参数的改变不影响实际参数。

形式参数：用于接受实际参数的变量
实际参数：实际参与运算的变量

栈：执行方法
堆：存储一些引用型数据的
方法去：存储一些CLASS文件的
本地方法区：存储一些本地方法的
寄存器：cpu

如果参数是引用数据类型：
        形式参数的改变直接影响实际参数
system.out.println(Arrays.toStingt(arr));
打印并遍历


Day6
面向对象是基于面向过程的变成思想

面向过程：强调的是每一个功能的步骤
面向对象：强调的是对象，由对象去调用功能

类:是一组相关的属性和行为的集合
对象：就是该对象的具体体现

描述一类事物的时候：定义为类

类是如何和事物进行对应
        类：成员变量
            成员方法

成员变量：和变量定义一样
        位置不同：类中，方法外
        初始化值：不需要给初始化值
       
局部变量：定义在方法里面的变量叫局部变量，必须初始化

成员方法：和方法定义一样
        去掉static

使用一个类，就是使用该类的成员（成员变量和成员方法）

格式：类名 对象名 =NEW 类名（）

访问成员
        成员变量：对象名.变量名
        成员方法：对象名.方法名（x）

在内存中位置不同
        成员变量：堆内存
        局部变量：栈内存
生命周期不同
        成员变量：随着对象的创建而存在，随着对象的消失而消失
        局部：随着方法调用而存在，随着方法调用完毕而消失

prvite
        修饰符
        可以修饰成员变量，修饰成员方法
        被修饰的的只能成员在本类中访问
针对private 提供get 和set方法用于获取成员变量的值，public修饰

面向对象：
        封装，继承，多态三个特征

        封装：把不需要对外展示的内容，隐藏起来，对外提供公共访问方式。
        好处：安全 提高代码复用性

如果有局部变量名和成员变量名相同时，在局部使用的时候，采用就近原则

构造方法
        给对象的数据进行初始化

格式
        方法名和类名相同
        没有返回值类型，void都不能写
        没有具体的返回值

调用构造方法
        格式
        类名对象名 = new 构造方法（。。。。）;
构造方法的注意事项
        如果我们给出构造方法，系统默认提供无参构造方法供我们使用
        如果给出构造方法，系统不再提供默认无参方法使用
        如果我们想使用有参构造方法，就必须自己提供无参构造
        构造方法可以重载

类名作为形式参数，其实这里就是该类对象

当返回值类型是类的时候，返回的就是该类的对象


讲了类的定义和调用

第一步
定义类 创建类

public class 类

public Student(){ 无参构造方法  public + 类名
}

定义 成员变量
String name;
private int age;     被private修饰的成员变量不能直接调用，只能本类中访问


pubilc void setAge(int a){          设置set方法为了设置成员变量的值，方法中无需返回值，但要注明赋值的类型（可以用判断条件语句进行筛选错误的信息）
        age =a;
}

public int getAge(){        设置get方法为了获取设置成员变量的后的值，有返回值，所以方法中要写出返回值类型
        return age;
}



定义 成员方法
public void (study)方法名（）{

}

第二部
创建一个主方法
public static void main(String[] args){
        创建类的对象   其实就是构造方法
        类名 对象名=new 类名（）；
        Student s =new Studen();

第三步 给成员变量赋值
        s.name ="";
        s.age=10;

第四部 调用成员方法
        s.study();

有参构造 调用方法
        Student s =new Studen(参数列表);
        s.方法名();
}

变量在使用的时候，如果局部变量和成员变量同名时，系统先就近在方法里找局部变量开始复制，这个叫就近原则，可以用this解觉，代表类中的对象引用

格式
        类名 对象名 =new 构造方法（）；
        Studeng s= new Sudent;

当第一个类中有一个方法，第二个类中调用了第一个类的方法，那么在第三个主方(test)法中必需创建第一和第二的对象，
并在主方法中调用第二个方法，传入第一个类的对象
Teach t =new Teach();
Student s=new Student();
t.test(s);