学习java记录~

作者: 楠瓜_Celine | 来源:发表于2018-07-31 15:37 被阅读0次

学习参考网址：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

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<a.length-1;i++){
            if(a[i]<a[i+1]){
                min=a[i];
                a[i]=a[i+1];    
                a[i+1]=min;                 
            }           
        }
        System.out.println(a[4]);                  
    }

}

②初始化数组

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<a.length-i-1;j++){
                    if(a[j]<a[j+1]){
                        int min=a[j];
                        a[j]=a[j+1];    
                        a[j+1]=min;                         
                     }                  
                 }      
            } 
            for (int k = 0; k < a.length; k++) {
            System.out.print(a[k] + " ");
            }           
        }
   }

④二维数组

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
        
    }

}

学习java记录~

一、2018.07.30(java相关安装、配置；HelloWord）

1、java和jdk的安装

2、第一个例子(HelloWord,哈哈哈哈)

3、eclipse安装

4、类和对象，属性，方法，参数

①java是面向对象的编程语言

②对象是类的实例化

③属性是类拥有的状态

④方法是对象或者类可以做的事情（功能）

5、变量

①基本变量类型（八种）

②类型间转换

③命名规则

④作用域

2018.8.2

6、操作符

①基本算数操作

②关系操作符

③逻辑运算符

④赋值操作符

⑤三元操作符

7、逻辑运算

①判断语句：if

②判断语句：switch

③循环语句：while

④循环语句：for

⑤continue和break语句

⑥结束当前循环和外部循环

综合练习题

Debug调试

2018.8.3

7、数组

①创建数组

②初始化数组

③排序（选择和冒泡法）

④二维数组

2018.8.6——下周继续

8、类和对象

①引用

②继承

③方法重载

④构造方法

2018..5

⑤this

⑥传参

9、接口与继承

2019.03.15

10、数字与字符串

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读