学习参考网址：http://how2j.cn/k/variable/variable-type/259.html
一、2018.07.30(java相关安装、配置；HelloWord）
1、java和jdk的安装
2、第一个例子(HelloWord,哈哈哈哈)
3、eclipse安装
4、类和对象，属性，方法，参数
①java是面向对象的编程语言
public class Hero {
String name; //姓名（类的属性）
float hp; //血量
float armor; //护甲
int moveSpeed; //移动速度
public static void main(String[] args) {
Hero garen = new Hero();//garen是一个对象，是对类Hero的实例化
garen.name = "盖伦";
garen.hp = 616.28f;
garen.armor = 27.536f;
garen.moveSpeed = 350;
Hero teemo = new Hero();
teemo.name = "提莫";
teemo.hp = 383f;
teemo.armor = 14f;
teemo.moveSpeed = 330;
}
}
②对象是类的实例化
new Hero(); //类的实例化就是对象
③属性是类拥有的状态
String name; //姓名（类的属性）
④方法是对象或者类可以做的事情（功能）
//获取护甲值（有返回类型的方法）
float getArmor(){
return armor;
}
//坑队友（void代表方法没有返回值）
void keng(){
System.out.println("坑队友！");
}
⑤方法的参数
void addSpeed(int speed){
//在原来的基础上增加移动速度
moveSpeed = moveSpeed + speed;
}
⑥例子
public class Hero {
String name; //姓名
float hp; //血量
float armor; //护甲
int moveSpeed; //移动速度
//坑队友
void keng(){
System.out.println("坑队友！");
}
//获取护甲值
float getArmor(){
return armor;
}
//增加移动速度
void addSpeed(int speed){
//在原来的基础上增加移动速度
moveSpeed = moveSpeed + speed;
}
public static void main(String[] args) {
Hero garen = new Hero();
garen.name = "盖伦";
garen.moveSpeed = 350;
garen.addSpeed(100);
}
}
⑦练习
image.png
5、变量
①基本变量类型（八种）
-
整型 （4种）
image.png 字符型 （1种）
char类型用于存放一个字符，值用单引号'表示 (双引号表示字符串)
其长度和short一样，也是16位的，只能存放一个字符，超过一个字符就会产生编译错误-
浮点型 （2种）
image.png -
布尔型 （1种）
image.png String类型
String类型其实并不是基本类型，但是它是如此广泛的被使用
package com.java0724;
public class TestVariable {
public static void main(String[] args) {
double a=4.14;
float b=2.769343f;
int c=365;
int d=12;
char e='吃';
boolean f=false;
String h="不可描述";
System.out.println("a= "+a);
System.out.println("b= "+b);
System.out.println("c= "+c);
System.out.println("d= "+d);
System.out.println("e= "+e);
System.out.println("f= "+f);
System.out.println("h= "+h);
}
}
运行结果：
a= 4.14
b= 2.769343
c= 365
d= 12
e= 吃
f= false
h= 不可描述
②类型间转换
低精度可以自动转换成高精度的
高精度转换成低精度的有时会出现编译错误
③命名规则
变量命名只能使用字母 数字 _
变量第一个字符 不能使用数字
blabla。。。
④作用域
属性的作用域是：从其声明的位置开始的整个类
参数的作用域是：该方法内的所有代码
局部变量的作用域是：其作用域在声明开始的位置，到其所处于的块结束位置
final修饰的变量是：不能改变，只有一次赋值的机会
image.png
2018.8.2
6、操作符
①基本算数操作
package exercise1;
public class Count {
public static void main(String[] args) {
int i = 10;
int j = 5;
int a = i+j;//加
int b = i-j;//减
int c = i*j;//乘
int d = i/j;//除
int e = i%j;//余
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("c="+c);
System.out.println("d="+d);
System.out.println("e="+e);
System.out.printf("%d,%d,%d,%d,%d",a,b,c,d,e);
}
}
运算结果
a=15
b=5
c=50
d=2
e=0
15,5,50,2,0
练习(用到了输入类Scanner)
image.png
自增/自减(遇到自增自减就有点晕）
public class HelloWorld {
public static void main(String[] args) {
int i = 5;
System.out.println(i++); //输出5，先取值再运算
System.out.println(i); //输出6
int j = 5;
System.out.println(++j); //输出6，先运算再取值
System.out.println(j); //输出6
}
}
int i = 1;
int j = ++i + i++ + ++i + ++i + i++;
j =2+2+4+5+5=18
②关系操作符
public class HelloWorld {
public static void main(String[] args) {
int a = 5;
int b = 6;
int c = 5;
System.out.println(a>b); //返回 false
System.out.println(a>=c); //返回 true
System.out.println(a==b); //返回false
System.out.println(a!=b);//返回true
}
}
③逻辑运算符
与 & ； &&
public class HelloWorld {
public static void main(String[] args) {
//长路与 无论第一个表达式的值是true或者false,第二个的值，都会被运算
int i = 2;
System.out.println( i== 1 & i++ ==2 ); //无论如何i++都会被执行，所以i的值变成了3
System.out.println(i);
//短路与 只要第一个表达式的值是false的，第二个表达式的值，就不需要进行运算了
int j = 2;
System.out.println( j== 1 && j++ ==2 ); //因为j==1返回false,所以右边的j++就没有执行了，所以j的值，还是2
System.out.println(j);
}
}
或 | ； ||
public class HelloWorld {
public static void main(String[] args) {
//长路或 无论第一个表达式的值是true或者false,第二个的值，都会被运算
int i = 2;
System.out.println( i== 1 | i++ ==2 ); //无论如何i++都会被执行，所以i的值变成了3
System.out.println(i);
//短路或 只要第一个表达式的值是true的，第二个表达式的值，就不需要进行运算了
int j = 2;
System.out.println( j== 2 || j++ ==2 ); //因为j==2返回true,所以右边的j++就没有执行了，所以j的值，还是2
System.out.println(j);
}
}
取反 ！
public class HelloWorld {
public static void main(String[] args) {
boolean b = true;
System.out.println(b); //输出true
System.out.println(!b);//输出false
}
}
异或 ^
public class HelloWorld {
public static void main(String[] args) {
boolean a = true;
boolean b = false;
System.out.println(a^b); //不同返回真
System.out.println(a^!b); //相同返回假
}
}
④赋值操作符
public class HelloWorld {
public static void main(String[] args) {
int i =3;
i+=2;
System.out.println(i);
int j=3;
j=j+2;
System.out.println(j);
}
}
⑤三元操作符
public class HelloWorld {
public static void main(String[] args) {
int i = 5;
int j = 6;
int k = i < j ? 99 : 88;
// 相当于
if (i < j) {
k = 99;
} else {
k = 88;
}
System.out.println(k);
}
}
练习
package exercise1;
import java.util.Scanner;
public class HelloWorld {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("今天是周几：");
int a =s.nextInt();
String b=a<=5?"工作日":"休息日";
System.out.println("今天是"+b);
}
}
7、逻辑运算
①判断语句：if
package exercise1;
import java.util.Scanner;
public class If {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入身高（cm):");
float heigh =s.nextFloat();
System.out.println("请输入体重（kg):");
float weigh =s.nextFloat();
s.close();
float BMI =weigh*10000/(heigh*heigh);
if(BMI<18.5)
System.out.println("身体状态是：体重过轻");
else if(BMI>=18.5&&BMI<24)
System.out.println("身体状态是：正常范围");
else if(BMI>=24&&BMI<27)
System.out.println("身体状态是：体重过重");
else if(BMI>=27&&BMI<30)
System.out.println("身体状态是：轻度肥胖");
else if(BMI>=35)
System.out.println("身体状态是：重度肥胖");
}
}
练习
package exercise1;
import java.util.Scanner;
public class If {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("请输入年份");
int year =s.nextInt();
if((year%400==0)||(year%4==0&&year%100!=0))
System.out.println("您输入的年份是闰年");
else
System.out.println("您输入的是平年");
}
}
②判断语句：switch
package exercise1;
import java.util.Scanner;
public class Switch {
public static void main(String[] args) {
Scanner s =new Scanner(System.in);
System.out.println("请输入一个季节（1-12）");
int season =s.nextInt();
switch(season){
case 1:
System.out.println("春天来啦");
break;
case 2:
System.out.println("春天来啦");
break;
case 3:
System.out.println("春天来啦");
break;
default:
System.out.println("不是春天");
}
}
}
③循环语句：while
package exercise1;
import java.util.Scanner;
public class While {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner s = new Scanner(System.in);
System.out.println("请输入一个整数");
int n = s.nextInt();
int m=n;
s.close();
int mul=1;
while(n>1){
mul=mul*n;
n=n-1;
}
System.out.println(m+"！="+mul);
}
}
请输入一个整数
10
10！=3628800
package exercise1;
import java.util.Scanner;
public class DoWhile {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner s = new Scanner(System.in);
System.out.println("请输入一个整数");
int n = s.nextInt();
int m=n;
int mul=1;
s.close();
do{
mul = mul*n;
n=n-1;
}while(n>1);
System.out.println(m+"！="+mul);
}
}
④循环语句：for
package exercise1;
import java.util.Scanner;
/*天朝有一个乞丐姓洪，去天桥要钱
第一天要了1块钱
第二天要了2块钱
第三天要了4块钱
第四天要了8块钱
以此类推...
问题： 洪乞丐干10天，收入是多少？
*/
public class For {
public static void main(String[] args) {
// TODO Auto-generated method stub
int sum =1;
int x=1;
for(int y=1;y<10;y++){
x=x*2;
System.out.println(x);
sum=sum+x;
}
System.out.println(sum);
}
}
⑤continue和break语句
package exercise1;
public class HelloWorld {
public static void main(String[] args) {
//结束整个循环
for (int j = 1; j < 10; j++) {
if(j%2==0)
break; //如果是双数，直接结束循环
System.out.println(j);
}
}
}
运行结果
1
package exercise1;
public class HelloWorld {
public static void main(String[] args) {
//continue是结束此次循环，进行下一次循环
for (int j = 0; j < 10; j++) {
if(0==j%2)
continue; //如果是双数，后面的代码不执行，直接进行下一次循环
System.out.println(j);
}
}
}
运行结果
1
3
5
7
9
练习
package exercise1;
/*
假设你月收入是3000，除开平时花销，每个月留下1000块钱进行投资。
然后你认真的钻研了 《股票和基金 21天从入门到精通》，达到了每年20%的投资回报率。
那么问题来了，以每个月投资1000块钱的节奏，持续投资多少年，总收入达到100万
（复利计算按照每年12000投入计算，不按照每月计息）
复利公式：
F = p* ( (1+r)^n );
F 最终收入
p 本金
r 年利率
n 存了多少年
*/
public class HelloWorld {
public static void main(String[] args) {
float p=1000;
float r=0.2f;
int n=0;
for(float sum=0;sum<=100000;sum+=p){
p=p*(1+r);
n++;
}
System.out.println(n);
}
}
⑥结束当前循环和外部循环
- 浮点型
- break:结束双层for循环里面的一层
- boolean变量：借助boolean变量可以结束外部一层循环
- 标签：结束外部循环
package exercise1;
public class Cycle {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
System.out.println(i+":"+j);
if(0==j%2)
break; //结束当前循环
}
}
}
}
运行结果
0:0
1:0
2:0
3:0
4:0
5:0
6:0
7:0
8:0
9:0
package exercise1;
public class Cycle {
public static void main(String[] args) {
boolean breakout = false; //是否终止外部循环的标记
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
System.out.println(i + ":" + j);
if (0 == j % 2) {
breakout = true; //终止外部循环的标记设置为true
break;
}
}
if (breakout) //判断是否终止外部循环
break;
}
}
}
运行结果
0：0
package exercise1;
public class Cycle {
public static void main(String[] args) {
boolean breakout = false; //是否终止外部循环的标记
outloop: //outloop这个标示是可以自定义的比如outloop1,ol2,out5
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
System.out.println(i+":"+j);
if(0==j%2)
break outloop; //如果是双数，结束外部循环
}
}
}
}
运行结果
0：0
综合练习题
package exercise1;
/*
寻找某两个数相除，其结果 离黄金分割点 0.618最近
分母和分子不能同时为偶数
分母和分子 取值范围在[1-20]
*/
public class Task {
public static void main(String[] args) {
double x=0.382;//设一个基础比较值（1/1-0.618）
int i = 0;//记录相近时的分子
int j = 0;//记录相近时的分母
for(int a=1;a<=20;a++){
for(int b=1;b<=20;b++){
if(a%2==0&&b%2==0)//限制不都是偶数
continue;
double c= (double)a/(double)b-0.618;
double d=Math.abs(c); //取绝对值
if(x>d){
x=d;
i=a;
j=b;
}//比较，取最小值
}
}
System.out.println("当x="+i+"\t y="+j+"时，离黄金分割点最近,相差"+x);
}
}
运行结果
当x=8 y=13时，离黄金分割点最近,相差0.002615384615384575
Debug调试
菜单->Run
image.png
image.png
image.png
2018.8.3
7、数组
数组是一个固定长度的，包含了相同类型数据的 容器
①创建数组
- 声明数组: int[] a; 或者 int a[];
- 创建数组:new int[5];
public class HelloWorld {
public static void main(String[] args) {
//声明一个引用
int[] a;
//创建一个长度是5的数组，并且使用引用a指向该数组
a = new int[5];
int[] b = new int[5]; //声明的同时，指向一个数组
}
}
练习
package exercise1;
public class Min {
public static void main(String[] args) {
int a[] = new int[5];
int min = 0;
System.out.println("数组中的各个随机数如下：");
for(int n=0;n<5;n++){
a[n]=(int)(Math.random()*100); //Math.random()取0-1之间随机数方法
System.out.println(a[n]);
}
System.out.println("数组从大到小排序，新的数组如下：");
for(int i=0;i②初始化数组
public class HelloWorld {
public static void main(String[] args) {
//写法一： 分配空间同时赋值
int[] a = new int[]{100,102,444,836,3236};
//写法二： 省略了new int[],效果一样
int[] b = {100,102,444,836,3236};
//写法三：同时分配空间，和指定内容
//在这个例子里，长度是3，内容是5个，产生矛盾了
//所以如果指定了数组的内容，就不能同时设置数组的长度
int[] c = new int[3]{100,102,444,836,3236};
}
}
③排序（选择和冒泡法）
冒泡排序
package exercise1;
public class Sort {
public static void main(String[] args) {
int a [] = new int[]{18,62,68,82,65,9};
for (int i = 0; i < a.length; i++) {
for(int j=0;j④二维数组
package exercise1;
/*
定义一个5X5的二维数组。 然后使用随机数填充该二维数组。
找出这个二维数组里，最小的那个值，并打印出其二维坐标
*/
public class Array {
public static void main(String[] args) {
int a[][]=new int[5][5];
int x=0;
int y=0;
for(int i=0;i<5;i++){
for(int j=0;j<5;j++){
a[i][j]=(int) (Math.random()*100);
System.out.printf("%d ",a[i][j]);
}
System.out.println(" ");
}
int min=a[0][0];
System.out.println("");
for(int n=0;n<5;n++){
for(int k=0;k<5;k++){
if(a[n][k]<=min){
min=a[n][k];
x=n;
y=k;
}
}
}
System.out.println("最小的数是"+min);
System.out.println(" 此时的坐标是["+x+"]"+"["+y+"]");
}
}
2018.8.6——下周继续
8、类和对象
①引用
如果一个变量的类型是 类类型，那么该变量又叫做引用。
- 多个引用一个对象：一个对象可以被多个引用所指向
- 一个引用多个对象：一个引用，同一时间只能指向同一对象
public class Hero {
String name; //姓名
float hp; //血量
float armor; //护甲
int moveSpeed; //移动速度
public static void main(String[] args) {
//使用一个引用来指向这个对象
Hero h1 = new Hero();
Hero h2 = h1; //h2指向h1所指向的对象
Hero h3 = h1;
Hero h4 = h1;
Hero h5 = h4;
//h1,h2,h3,h4,h5 五个引用，都指向同一个对象
}
}
package charactor;
public class Hero {
public String name;
protected float hp;
public static void main(String[] args) {
Hero garen = new Hero();
garen = new Hero();//引用garen指向第二个对象
}
}
②继承
public class Item {
String name;
int price;
}
public class Weapon extends Item{
int damage; //攻击力
public static void main(String[] args) {
Weapon infinityEdge = new Weapon();
infinityEdge.damage = 65; //damage属性在类Weapon中新设计的
infinityEdge.name = "无尽之刃";//name属性，是从Item中继承来的，就不需要重复设计了
infinityEdge.price = 3600;
}
}
③方法重载
public class Hero {
String name; //姓名（类的属性）
float hp; //血量
float armor; //护甲
int moveSpeed; //移动速度
public static void main(String[] args) {
Hero garen = new Hero();//garen是一个对象，是对类Hero的实例化
garen.name = "盖伦";
garen.hp = 616.28f;
garen.armor = 27.536f;
garen.moveSpeed = 350;
Hero teemo = new Hero();
teemo.name = "提莫";
teemo.hp = 383f;
teemo.armor = 14f;
teemo.moveSpeed = 330;
}
}
public class ADHero extends Hero {
public void attack() {
System.out.println(name + " 进行了一次攻击 ，但是不确定打中谁了");
}
// 可变数量的参数
public void attack(Hero... heros) {
for (int i = 0; i < heros.length; i++) {
System.out.println(name + " 攻击了 " + heros[i].name);
}
}
public static void main(String[] args) {
ADHero bh = new ADHero();
bh.name = "赏金猎人";
Hero h1 = new Hero();
h1.name = "盖伦";
Hero h2 = new Hero();
h2.name = "提莫";
bh.attack(h1);
bh.attack(h1, h2);
}
}
④构造方法
方法名和类名一样（包括大小写），没有返回类型
实例化一个对象的时候，必然调用构造方法
2018..5
⑤this
- 引用成员变量:将局部变量的值传递给成员变量
Public Class Student {
String name; //定义一个成员变量name
private void SetName(String name) {
//定义一个参数(局部变量)name
this.name=name; //将局部变量的值传递给成员变量
}
}
- 调用类的构造方法
//定义一个类，类的名字为student。
public class Student {
//定义一个方法，名字与类相同故为构造方法
public Student() {
this(“Hello!”);
}
//定义一个带形式参数的构造方法
public Student(String name) {
}
}
- 返回对象的值/返回类的引用
public Class Student {
String name; //定义一个成员变量name
private void SetName(String name) { //定义一个参数(局部变量)name
this.name=name; //将局部变量的值传递给成员变量
}
Return this
}
⑥传参
变量有两种类型 基本类型 和类类型
参数也是变量，所以传参分为
- 基本类型传参
- 类类型传参
引用与赋值
- 基本变量= 即赋值
- 类类型变量 = 即引用
9、接口与继承
API（Application Programming Interface,应用程序编程接口）
接口（Interface）：
package charactor;
public interface AD {
public void physicAttack();
}
package charactor;
public interface AP {
public void magicAttack();
}
package charactor;
import exercise1.Hero;
public class ADAPHero extends Hero implements AD,AP {
@Override
public void magicAttack() {
// TODO Auto-generated method stub
}
@Override
public void physicAttack() {
// TODO Auto-generated method stub
}
}