1.关键字、标识符、注释
//关键字：在JAVA中对某些单词赋予了特殊功能，他们就成java中的关键字（以红色标识）
//package,import,public,class,static,void,new...
//标识符：给类，变量，接口起的名字，称为一个标识符
//day1.part2(包名)，Demo1（类名），main（方法名），args（变量名）
//类开头（大写），标识符（小写）
//HTML<!-- -->,CSS/**/,js// /**/
// //单行注释
// /**/多行注释
/**
* 文件注释 开发场景中使用
* @author Administrator
*功能
*日期
*方法
*/
2.数据类型
/在JAVA中有两大类数据类型
//1.引用数据类型(String)复杂数据类型-堆内存
//2.基础数据类型（int,char,double,boolean...）简单数据类型-栈内存
//基础数据类型分类:(byte,short,int,long,float,double,char,boolean一共8种)
//1.整数类型
byte no1 = 120;//字节类型-128~127
short no2 =12000;//短整型-32768~32767
int no3 = 120000000;//默认整型-2的31次方~2的31次方-1
long no4 = 1500000000;//长整型-2的63次方~2的63次方-1
//请问，电话号码，身份证号码，适合用哪种类型来声明？使用字符串
//2.小数类型
//精度，小数点后的位数（double的精确度高于float）
float no5 = 3.14f;//单精度
//float no5 = (float)3.14;
https://blog.csdn.net/nh5431313/article/details/72461226
单精度和双精度
double no6=3.1415926;//双精度
//BigDecimal 大精度类型(引用类型)
//3.字符类型,汉字占两个字节，数字拉丁字符占一个字节（单引号）
char ch1 ='0';
char ch2 ='o';
char ch3 ='O';
char ch4 ='零';
//4.布尔类型，表示真（true）假（false）
boolean areYouCrazy = true;
public static void main(String[] args) {
System.out.println("以上所描述的数据类型，都可以看做是一个变量的初始化过程");
byte,short,int,long的默认值是0
// String的默认值是null
// char的默认值是'\u0000'
// float,double的默认值是0.0
3.数据类型转换+包装类
一、//将int类型的money1. 转换成double类型//小=>大自动转换类型
//byte-short-int-long-float-double
money2=money1;
//强制类型转换会出现精度丢失的问题，在软件开发过程中是不推荐使用的
double price1 = 35.98;
byte price2;
//将price1转换成byte类型
price2 = (byte)price1;
//特殊的类型转换（字符-整数）
char c1='黑';
char c2='小';
char c3='明';
int no1 = c1;
int no2 = c2;
int no3 = c3;
System.out.println("我就是班长:"+no1+no2+no3);
System.out.println(no1);
System.out.println(no2);
System.out.println(no3);
//Java中每一个汉字都对应了一组数字，他们是遵照Unicode编码表来进行编制的
c1= (char)no1;
c2= (char)no2;
c3= (char)no3;
System.out.println(c1);黑
System.out.println(c2);小
System.out.println(c3);明
二、包装类
包装类： Java为每个基本类型都提供了包装(Wrapper Class)
基本数据类型 包装类
byte Byte
boolean Boolean
short Short
char Character
int Integer
long Long
float Float
double Double
Integer类常用的方法有intValue()方法 和parseInt()方法
//byte,short,int,long,float,double
//自动类型转换(小转大)
//强制类型转换(大转小)进度丢失
//字符-数字(Unicode,ASCII);
//字符串-数字
String str1 = "9527";
//int类型对应的包装类，提供了大量转换方法
//Integer.valueOf(i) //返回Integer
int no1 = Integer.valueOf(str1); //自动拆箱
System.out.println(no1);
//Integer.parseInt(i) //返回int
Integer no2 = Integer.parseInt(str1); //自动装箱
System.out.println(no2);
https://blog.csdn.net/u010126792/article/details/61616412
自动拆箱（unboxing）&自动装箱(boxing)
自动拆箱和自动装箱定义：
自动装箱是将一个java定义的基本数据类型赋值给相应封装类的变量。
拆箱与装箱是相反的操作，自动拆箱则是将一个封装类的变量赋值给相应基本数据类型的变量
String str2 = "3.1415926";
double no3 = Double.valueOf(str2);
double no4 = Double.parseDouble(str2);
System.out.println(no3);
System.out.println(no4);
String str3 = "饿";
char ch1 = str3.toCharArray()[0];
char ch2 = str3.charAt(0);
System.out.println(ch1);
System.out.println(ch2);
//基础数据类型 和 包装类 相互转换
// int Integer
// byte Byte
// short Short
// long Long
// char Character
// boolean Boolean
// float Float
// double Double
4.变量
一、变量的初始化构成
//变量：在程序运算中可以改变其值的某个标识符
//如何声明一个变量
String myname;//声明一个变量（数据类型 变量名;）
//如何对变量赋值
myname ="特朗普";
//初始化可以简写为String myname = "特朗普";
System.out.println("美国总统"+myname+"访问大学");
myname = "丰";
System.out.println("美国总统"+myname+"访问大学");
//在程序中有些标识符表示值是不可改变的---常量（final）--最好全大写
final char FIRSTNAME = '吴';
//FIRSTNAME ='黄';修改失败，因为FIRSTNAME被final所修饰，是一个常量
//JAVA中变量名声明的规则
//变量名的组成：
//1.拉丁字母,数字，下划线，$，￥，汉字
//2.不能以数字开头，不推荐使用￥、汉字
//3.不能使用Java中的关键字，保留字
//4.见词明义，简单明了，不宜过长
//String food= "螺蛳粉";
二、变量的生命周期
Java中有3种变量，分别为类变量（静态变量）、实例变量（）和某个方法中临时定义的局部变量（本地变量）。不同变量的生命周期不同
https://www.cnblogs.com/oraser/p/6428286.html
https://blog.csdn.net/xiaoyun8989/article/details/78058868
变量详解（概念和分类、声明、命名、初始化）
(1)变量的概念和分类：
概念：内存中的存储空间，用于存放运算过程中的数据
变量分类：局部变量、成员变量、类变量
局部变量：
局部变量声明在方法、构造方法或者语句块中；
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
成员变量：
实例变量声明在一个类中，但在方法、构造方法和语句块之外；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
类变量(也叫静态变量)：
类变量也称为静态变量，在类中以static关键字声明，但必须在方法、构造方法和语句块之外
默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化
5.运算符
//运算符+表达式
//算术运算符
//比较运算符
//逻辑运算符
//算数运算符（+，-，*，/，%）;
二元运算简化写法+=，-=
//自运算（++，--）：
++,--在前，则先执行自运算，再执行其他操作
++,--在后，则先执行其他操作，再执行自运算
比较运算符（<,>,>=,<=,!=,==）;真（true）假（false）
逻辑运算符
//逻辑或||，逻辑与&&，逻辑非！，逻辑异或^ 真（true），假（false）
//或者关系，逻辑||在判断左边的表达式成立的时候，则马上会进行短路（true-短路-true(短路效果），返回true值
false-true-true
true-false-true
//并且关系true-true-true （false-短路-false(短路效果)）
//逻辑异或^关系 男男-false 女女-false 男女-true
//逻辑非!
System.out.println(!!(!(a!=c) && !(c>a)));//false
附加：//三目运算表达式
int no1 = 10;
int no2 = 20;
//表达式1如果成立，则把？后的值赋值no3，如果不成立则把:后的值赋给no3
int no3 = no1+no2>=no2+10 ? 50 : 100;
6.选择结构if-else
//Java中的程序结构
//顺序结构:自上而下地逐行执行代码
//条件结构:
//循环结构:
//程序中的选择结构
//语法1：if-else结构
//语法2：switch结构
语法1：if-else结构的单分支
System.out.println("你说说此刻你最想吃什么？");
Scanner sc = new Scanner(System.in);
String food = sc.next();
//在Java中==比对的是二者使用引用的同一个内存地址
//如果String需要比对纯字符编码是否相等，那么需要调用equals()方法
//每个单分支if都是一个独立的逻辑判断单元
if(food.equals("黄焖鸡米饭")){
System.out.println("听上去不错");
}
if(food.equals("榴莲")){
System.out.println("这个爽");
}
if(food.equals("水")){
System.out.println("马上");
}
// if(food.equals("红烧鱼"));{
// System.out.println("好想吃啊");
// }
//在if结构中，如果你的业务代码只有一条，则可以省略大括号
//非常不建议省略，影响代码可读性
//if双分支结构中，当if中的条件表达式不满足的时候，则执行else语句块中的业务
//每个if-else双分支都是单独的逻辑判断单元
//多分支结构在双分支结构的基础上，多了一个else if()条件语句块
//这并不代表，多个条件能够同时成立，他往往只会满足第一个匹配的条件
//最后的else在以上都没匹配成功后，才默认的执行
//if结构的嵌套使用
7.选择结构switch-case+区别
与if-else比较，switch-case的优点在于：
* if-else多用于范围区间值比对，
* switch-case多用于等值比对
可以利用switch的实现批处理
增加了代码的可读性
使代码更容易编写,性能更高
switch不能实现嵌套,但是它可以实现嵌套if-else结构
System.out.println("请输入省份简称");
Scanner sc = new Scanner(System.in);
char pro = sc.next().toCharArray()[0];
//switch支持byte,short,int,char,jdk1.7之后支持String
switch(pro){ //switch是选择结构的关键字，表示开始匹配某个条件
case '鄂': //case 用于匹配单个条件，后面跟上匹配的值
System.out.println("湖北省");//条件满足的业务语句
break;//当执行业务后，使用break跳出当前的switch结构，结束本次判断
case '辽':
System.out.println("辽宁省");
break;
case '桂':
System.out.println("广西省");
break;
case '宁':
System.out.println("宁夏");
break;
default:
System.out.println("不认账这个简称");
break;
}
8.循环结构
//循环语法
//1-while循环
//2-dowhile循环
//3-for循环
//为了快捷重复去做某一个业务，Java中可以使用循环的语法来实现
//循环的三要素
//1循环的起始变量
//2循环的条件
//3起始变量的迭代
//注意：如果不编写变量的迭代，导致循环条件永远成立，则形成了死循环
while循环
int i = 1;//起始变量
while(i<=10){//循环的条件
System.out.println("摔了"+i+"跤");
i++;//起始变量的迭代
}
do-while需要先执行一次循环体，然后判断循环条件是否成立如果成立则继续循环
//使用do-while()实现用户登录
System.out.println("===三国杀===");
System.out.println("请输入用户信息");
boolean flag = false;
do{
System.out.print("账号：");
Scanner sc = new Scanner(System.in);
String name = sc.next();
System.out.print("密码：");
Scanner sc1 = new Scanner(System.in);
String pass = sc1.next();
if(name.equals("pengsir") && pass.equals("666")){
System.out.println("恭喜！登录成功");
flag = true;
}else{
System.out.println("您输入的账号密码有误，请重新输入");
}
}while(flag == false);
}
//for(起始变量;循环的条件;变量的迭代){
//循环的业务
//}
System.out.println("通知通知，还有10秒爆炸，各位赶紧逃离");
// System.out.println("开始读秒:");
// for(int i=10;i>0;i--){
// System.out.println(i);
// Thread.sleep(1000);//Thread是一个线程类，sleep是一个静态休眠方法
// }
// System.out.println("BOOM!!!");
9.break,continue
//break:跳出当前的循环机构，或者switch结构
public class Demo4 {
public static void main(String[] args) {
//使用for循环完成从1+100的合值
//如果碰到第一个能够被3整除的数字，马上终止循环，计算结果
int sum = 0;
for(int i=1;i<=100;i++){
if(i%3==0){
break;//跳出当前的循环结构
}
sum = sum + i;
}
System.out.println("使用break之后的值是"+sum);
}
}
//continue:终止本次循环，进入到下一次循环
public class Demo5 {
public static void main(String[] args) {
//使用for循环完成从1+100的合值
//凡是能被2整除的数字全部过滤
int sum = 0;
for(int i=1;i<=100;i++){
if(i%2==0){
continue;
}
sum = sum + i;
}
System.out.println("使用break之后的值是"+sum);
}
}
10.数组-静态初始化
一.为什么要使用数组
a.过程繁琐
b.变量定义太多
c.操作变量不方便
二.Java中数组的概念
Java中的数组即存放一些相同元素的集合
三.一维数组的声明
//1.声明一个数组
//2.给数组赋值添加长度,如果数组静态初始化时不设置长度，报错。
//String数组类型
//[]数组标识
//com数组名称
//静态初始化
String[] com = new String[5];
com[0] = c1;
com[1] = c2;
com[2] = c3;
com[3] = c4;
com[4] = c5;
System.out.println(com);
//java.lang.ArrayIndexOutOfBoundsException
//数组下标越界异常
//com[5] = "中兴通讯";
//遍历数组：轮流查看数据集中的每一个元素
//使用常规循环来进行遍历(for,while,do-while)
//length属性用来表示数组的长度
for(int i=0;i<com.length;i++){
System.out.println(com[i]);
}
System.out.println("--------------------");
//for each循环 ：jdk 1.4之后新增的语法
//1.请问需要迭代的是哪个数据集？ com
//2.请问这个数据集中的每个元素是什么类型？String
//3.给数据集中的元素其实临时的变量名 str
for(String str :com){
System.out.println(str);
}
System.out.println("--------------------");
四、一维数组的默认初始化
//可能会遇到的问题,以及默认值
//int[] arrays = new Array[5]; 这是JS的写法
// int[] arrays = new int[0];
// System.out.println(arrays.length);//0
// System.out.println(arrays[0]);//越界
// int[] arrays = new int[1];
// System.out.println(arrays.length);//1
// System.out.println(arrays[0]);//0 int的默认值是0
// byte,short,int,long的默认值是0
// String的默认值是null
// char的默认值是'\u0000'
// float,double的默认值是0.0
基本类型的初始值基本类型默认值：
boolean false
char \u0000(null)
byte (byte)0
short (short)0
int 0
long 0L
float 0.0f
double 0.0d
上面的默认值，是当变量作为类的成员使用时才有的。
不管程序有没有显示的初始化，Java 虚拟机都会先自动给它初始化为默认值。
1、整数类型（byte、short、int、long）的基本类型变量的默认值为0；
2、单精度浮点型（float）的基本类型变量的默认值为0.0f；
3、双精度浮点型（double）的基本类型变量的默认值为0.0d；
4、字符型（char）的基本类型变量的默认为 “/u0000”；
5、布尔性的基本类型变量的默认值为 false；
6、引用类型的变量是默认值为 null；
7、数组引用类型的变量的默认值为 null。当数组变量的实例后，如果没有没有显示的为每个元素赋值，Java 就会把该数组的所有元素初始化为其相应类型的默认值。
}
}
11.数组-动态初始化
java中数组作为参数传递
要传递这么多：new String[5]{"王思聪","潘瑞","王烁","张量","汪雨"};
new String一下
//动态初始化
//特点：通过初始赋值，来指定长度
String[] names = new String[]{"王思聪","潘瑞","王烁","张量","汪雨"};
//for each遍历names
//增强for循环通过用于对数据集的遍历(数据集，集合...)
for (String string : names) {
System.out.println(string);
}
//动态初始化语法中，不能指定长度
//String[] names = new String[5]{"王思聪","潘瑞","王烁","张量","汪雨"};
int[] scores = new int[]{5};
System.out.println(scores.length);
System.out.println(scores[0]);
12.二维数组
//1.[3]:3个一维的字符串数组---维度
//2.[3]:每个一维数组中3个长度---长度
String[][] names = new String[3][3];
System.out.println(names);//内存地址：@15db9742
System.out.println(names[0]);//第一个一维数组的内存地址：@6d06d69c
names[0][0] = "刘备";
names[0][1] = "关羽";
names[0][2] = "张飞";
names[1][0] = "孙权";
names[1][1] = "周瑜";
names[1][2] = "鲁肃";
names[2][0] = "曹操";
names[2][1] = "郭嘉";
names[2][2] = "夏侯惇";
//遍历这个二位数组，先遍历一维数组，再遍历二维数组
// for(int i=0;i<names[0].length;i++){
// System.out.println(names[0][i]);
// }
for(int i=0;i<names.length;i++){//第一个
for(int j=0;j<names[i].length;j++){//第二个
System.out.println(names[i][j]);
}
System.out.println("----------");
}
13.类与对象的关系
类：对象的抽象
对象：类的实例化
类是对对象的描述，是创建对象的“模板”，是对象的抽象；
对象表示现实世界中某个具体的事物，是类的一个实例，是类的实例化结果。
14.访问修饰符
访问修饰符
封装中提供了4种访问控制级别一维数组的声明
访问修饰符有以下4个
1、public：共有的，最高的访问级别，类的public成员所有类的成员都可以访问
2、protected：受保护的，类的protected成员只能被该类的成员以及其子类成员访问。还可以被同一个包中其他类的成员访问
3、private：私有的，不对外公开，类的private成员只能被该类的成员访问，访问级别最低
4、默认，类的成员什么修饰符都没有，又叫包修饰符，只有类本身成员和当前包下类的成员可以访问。
变量，对象调用
//调用Hero()
public static void main(String[] args) {
Hero liu =new Hero();
liu.name = "刘备";
liu.skill = "仁德";
liu.life = 4;
liu.country = "蜀国";
Hero cao =new Hero();
cao.name = "曹操";
cao.skill = "奸雄";
cao.life = 4;
cao.country = "魏国";
Hero sun =new Hero();
sun.name = "孙权";
sun.skill = "制衡";
sun.life = 4;
sun.country = "吴国";
System.out.println("-----武将列表-----");
System.out.println("姓名\t技能 \t血量\t国家"); // \t空格
System.out.println(liu.name+"\t"+liu.skill+"\t"+liu.life+"\t"+liu.country);
System.out.println(cao.name+"\t"+cao.skill+"\t"+cao.life+"\t"+cao.country);
System.out.println(sun.name+"\t"+sun.skill+"\t"+sun.life+"\t"+sun.country);
System.out.println("______________________________________________________");
System.out.println("请输入要选择武将的名字：");
Scanner sc =new Scanner(System.in);
String name=sc.next();
if(name.equals("刘备")){
System.out.println(liu.country+"武将"+liu.name+"，他的技能是"+liu.skill+"，他有"+liu.life+"点血");
}else if(name.equals("曹操")){
System.out.println(cao.country+"武将"+cao.name+"，他的技能是"+cao.skill+"，他有"+cao.life+"点血");
}else if(name.equals("孙权")){
System.out.println(sun.country+"武将"+sun.name+"，他的技能是"+sun.skill+"，他有"+sun.life+"点血");
}else{
System.out.println("没有这个英雄");
}
}
循环，内外层循环控制（高级版）
public static void main(String[] args) {
for(int i=1;i<=9;i+=2){
for(int a=8;a>=i;a-=2){
System.out.print(" ");
}
for(int j=0;j<i;j+=9){
System.out.print("*");
for(int b=2;b<i;b++){
System.out.print(" ");
}
if(i!=1){
System.out.print("*");
}
}
System.out.println("");
}
for(int i=1;i<=7;i+=2){
for(int a=0;a<i;a+=2){
System.out.print(" ");
}
for(int j=7;j>=i;j-=7){
System.out.print("*");
for(int b=5;b>=i;b--){
System.out.print(" ");
}
if(i!=7){
System.out.print("*");
}
}
System.out.println("");
}
}
内外层控制（简单版）
public static void main(String[] args) {
for(int i=1;i<=9;i+=2){
for(int a=8;a>=i;a-=2){
System.out.print(" “);
}
for(int j=0;j<i;j++){
System.out.print(”*");
}
System.out.println("");
}
for(int i=1;i<=7;i+=2){
for(int a=0;a<i;a+=2){
System.out.print(" ");
}
for(int j=7;j>=i;j--){
System.out.print("*");
}
System.out.println("");
}
}
扫一扫
18万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
