1.java的原始数据类型：
(1).
整数型
：
byte short int long
int
整数型 表达的范围
2^31-1 ~ -2^31 -21.47
亿
~ 21.47
亿
int i=10; int age=20;
(2).
浮点型
：
float double
double
表示小数 默认只能精确到小数点后
15
位
double d=10.0; double price=10.234;
(3).
字符型
：
char
char c='a'; char c1='
中
'; //
单个字符表示 只能用单引号
String s="abc"; String s1="
中国
"; //
字符串表示 只能用双引号 可以表示多个字符
(4).
布尔型
：
boolean
表示 真 假 两个值
boolean b=true; boolean b1=false;
2.变量：
使用不同的数据类型来定义变量用来存储不同的数据
String name;// name
就是一个字符串变量 可以存储多个字符
int age;// age
就是一个整数变量 可以存储整数
3.概念：
class类别：
在Java中，class是一种重要的概念，它用于定义对象的属性和行为。类是一种模板或蓝图，用于创建对象。类的定义通常包含在一个.java文件中，类名必须与文件名相同。在Java中，每个类都应该包含一个入口点，即一个主类（Main class），用于执行程序的起点。
分类的标准：共同的属性、特征、行为、功能
表达一个类别： 实际上就是描述这个类别的属性、特征、行为、功能
对象：
在Java中，对象是一个类的实例。一个类可以定义对象的属性（也称为字段）和行为（也称为方法）。对象是具有状态和行为的实体。
4.程序中的类与对象：
类：
(1).关键字： class
(2).格式：
public class
类名
{ }
(3).内容： 用代码来描述一类事物的属性、特征、行为、功能
(4).属性：表达数据信息 使用变量表达
(5).方法：表达行为
/
功能逻辑 使用函数
/
方法表达
最简单的方法：
void
方法名
(){ }
大括号中就可以写多行代码来表示逻辑
例如：void study(){ } void play(){ }
带参数的方法：
参数: 一个方法在执行前输入的数据，方法名后的大括号就是参数括号
使用参数：
1
： 定义参数： 参数的数据类型 参数名
2
： 在方法中使用参数名替代参数数据使用
例如: foodName
吃的食物名
类型是字符串：
void eat(String foodName){ System.out.println (name + "在吃饭
,
吃的是
" +
foodName); }
3
： 方法在被对象调用时，再给定对应类型的数据 放到括号中
例如:stu1.eat("
苹果
")
对象：
类：像一个模板 ，规定了有哪些属性以及方法
使用类创建一个对象：给这个对象中的属性赋值,对象来使用方法
关键字:
new
格式： 类名 对象名
= new
类名
();
例如：Student stu1 = new Student();
对象调用自己的属性赋值：
对象名
.
属性名
=
值
例如：
stu1.name = "
张三
"
对象调用方法执行：
对象名
.
方法名
();
stu1.study();
运行代码需要使用主函数： main
main
函数是一个特殊的函数，程序的入口，程序的执行从
main
函数开始
main
函数的格式：
public static void main(String[] args){ }
main
函数必须写在程序的某个类中
学生类(姓名 学号 年龄 性别 班级 | 学习 玩耍 吃饭 睡觉 上课 考试)
// 学生类(姓名 学号 年龄 性别 班级 | 学习 玩耍 吃饭 睡觉 上课 考试)
public class Student{
// 属性
String name;
String stu_id;
int age;
String sex;
String class_name;
int stu_score;
// 方法
// time 代表玩耍的时间 单位为小时
void play(int time){
// 方法中可以直接使用 属性来替代数据
System.out.println (name + "玩耍了" + time + "小时");
}
// foodName 吃的食物名 类型是字符串
void eat(String foodName){
System.out.println (name + "在吃饭,吃的是" + foodName);
}
void sleep(){
System.out.println (name + "在睡觉");
}
void study(){
stu_score = stu_score + 10;
System.out.println (name + "在学习,学分增加了10分，现在的学分是：" + stu_score);
}
void exam(){
stu_score = stu_score + 20;
System.out.println (class_name + "的" + name + "在考试,学分增加了20分，现在的学
分是：" + stu_score);
}
// 程序执行逻辑入口
public static void main(String[] args){
// 创建学生对象
Student stu1 = new Student ();
// 学生对象stu1 还需要给对象的属性赋值
stu1.name = "张三";
stu1.stu_id = "20190101";
stu1.age = 18;
stu1.stu_score = 10;
stu1.class_name = "英语2班";
// 对象赋值之后可以用来使用方法 调用方法 对象名.方法名();
stu1.play (2);
stu1.sleep ();
stu1.eat ("面条");
stu1.exam ();
stu1.study ();
// 测试第二个学生对象
Student stu2 = new Student ();
stu2.name = "李四";
stu2.stu_id = "20190102";
stu2.age = 19;
stu2.stu_score = 20;
stu2.class_name = "英语3班";
stu2.play (1);
stu2.eat ("饺子");
stu2.sleep ();
stu2.exam ();
stu2.study ();
stu2.eat ("烧烤");
// 一个类可以创建多个对象 重复使用类
// 每个对象都是独立存在的，数据互相不干扰
}
}方法：方法是一个功能/行为的描述
空参数无返回值方法：
public void
方法名
(){}
有参数方法：
public void
方法名
(
参数类型 参数名
){ }
有返回值方法：
public
返回值类型 方法名
(){ return
返回值
; }
有参数有返回值方法：
public
返回值类型 方法名
(
参数类型 参数名
){ return
返回值
; }
有多个参数的方法：
public void
方法名
(
参数类型 参数名
1,
参数类型 参数名
2){ }
参数：
没有参数：空着
有参数： 参数类型 参数名
有多个参数：参数类型 参数名
1,
参数类型 参数名
2
参数名不能一致
例如：绝对值
public class Math{
// 属性：
// 方法：
// 求整数的绝对值
// 传入一个整数参数
// 返回一个整数的返回值
public int abs(int num){
if(num < 0){
return -num;
} else{
return num;
}
}
// 计算4个数中的最小值
public int min(int a, int b, int c, int d){
}
public int min(int a, int b){
if(a < b){
return a;
} else{
return b;
}
}
// 使用带有返回值以及参数的方法
public static void main(String[] args){
Math m = new Math ();
int num = -1200;
int r = m.abs (num); // 调用方法,传入参数 num ,定义一个变量接收返回值
// r 就是得到的返回值(输出) num是参数(输入)
int min = m.min (1, 2);
System.out.println (r);
System.out.println (min);
}
}
方法重载：
一个类中可以存在多个同名的方法，前提要求是方法的参数不一致
参数可以数量不同
参数可以类型不同
参数可以顺序不同
根据调用时，给入的参数来决定调用哪个
PK游戏
package
com.oop.pk;
public class HouYI{
// 属性：
String name;
String playerID;
int blood;
int ad;
int defense;
int lv;
public void lvUp(){
lv++;
System.out.println ("-----恭喜" + name + "升级了，当前等级：" + lv + "----");
}
// 技能1：
public void skill1(ZhangFei zf){
System.out.println ("技能1：万箭齐发");
// 伤害计算 公式：(攻击力+技能伤害)*技能等级
int num = (int) (ad * 1.5 + 200 + lv * 80);
System.out.println ("技能伤害伤害：" + num);
System.out.println ("对" + zf.name + "造成伤害：" + (num - zf.defense));
zf.blood -= (num - zf.defense);
System.out.println (zf.name + "剩余血量：" + zf.blood);
}
}
package
com.oop.pk;
public class ZhangFei{
// 属性：
String name;
String playerID;
int blood;
int ad;
int defense;
int lv;
public void lvUp(){
lv++;
System.out.println ("-----恭喜" + name + "升级了，当前等级：" + lv + "----");
}
// 方法1： 技能1：
public void skill1(HouYI hy){
System.out.println ("技能1：猛龙摆尾");
// 伤害计算 公式：(攻击力+技能伤害)*技能等级
// 后半部分是浮点数，需要强制转换为整数
int num = (int) (ad * 0.8 + 200 + lv * 50);
System.out.println ("技能伤害：" + num);
System.out.println ("对后羿造成伤害：" + (num - hy.defense));
hy.blood -= (num - hy.defense);
System.out.println ("后羿剩余血量：" + hy.blood);
}
}
package
com.oop.pk;
import
java.util.
Random;
public class PKGame{
public static void main(String[] args){
// 模拟选择角色过程 - 创建对象
HouYI hy1 = new HouYI ();
hy1.name = "后羿";
hy1.playerID = "10001";
hy1.blood = 2000;
hy1.ad = 120;
hy1.defense = 50;
hy1.lv = 3;
ZhangFei zf1 = new ZhangFei ();
zf1.name = "张飞";
zf1.playerID = "10002";
zf1.blood = 4000;
zf1.ad = 20;
zf1.defense = 60;
zf1.lv = 2;
// 模拟PK 回合PK
// while(hy1.blood > 0 && zf1.blood > 0){
// System.out.println ("------后羿对张飞使用技能1------");
// hy1.skill1 (zf1);
// System.out.println ("------张飞对后羿使用技能1------");
// zf1.skill1 (hy1);
// }
// 随机PK
Random random = new Random ();
while(hy1.blood > 0 && zf1.blood > 0){
int ri = random.nextInt (4);
// ri ： 0 1 2 3
if(ri == 0){
System.out.println ("------后羿对张飞使用技能1------");
hy1.skill1 (zf1);
} else if(ri == 1){
System.out.println ("------张飞对后羿使用技能1------");
zf1.skill1 (hy1);
} else if(ri == 2){
hy1.lvUp ();
} else if(ri == 3){
zf1.lvUp ();
}
}
System.out.println ("------PK结束------");
// 判断胜负
if(hy1.blood > 0){
System.out.println ("后羿胜利");
} else{
System.out.println ("张飞胜利");
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
