JAVA笔记.doc

第一章 进制数
JAVA用的是十进制，但底层用的是二进制。
十六进制：

十六进制一位数代表二进制四位数。

关系运算：

关系运算比算数运算优先级低，但比赋值运算高。
判断是否相等==和！=优先级低
6>5>4这句话是错的，6>5是true而true和数字是不能比较大小。
两个浮点数不能直接比较，浮点数做运算时存在误差，

Class 后面的类名和文件名完全一样，main方法是JAVA程序执行的入口点，所有单词不变，String中的S必须要大写，程序输出小括号中的内容可以变其他单词不变。

变量与数据类型

任何数据都可以用字符串（string）储存
变量的使用
Public class t1{
Public static void main (string args[]){
Int s ; //声明
S=10000; //赋值
System.out.println(s)；
}
}
字符串必须写在双引号里面，字符写在单引号里面。
String y=”张三” ; char b =’男’ ;
System.out.println(“姓名：”+y); //字符串和变量用+连接
变量的命名规则和常见错误

驼峰命名法：混合使用大小写 int myAge;
匈牙利命名：开头字母用变量类型缩写 int iMyAge;
大驼峰法： 开头字母用大写
运算符
%取余
=为赋值运算符
== 为关系运算符 关系运算符比较的结果：boolean类型
逻辑运算符 三目运算 ：布尔类型表达式？值1：值2

Int i = 10>5 ?1:2 ; 先判断布尔表达式真取值1 假取值2

Scanner input = new scanner(system .in);
Int vip = intput.nextInt ();

基础语法
循环结构
For 语句
Double d = Math.random ()*10;
System.out.println ((int)d) // 强制类型转换
等同于int d =（int）(Math.random ()*10);
多重循环 使用 if ,else if,if
Switch 语句
通过表达式成立与否选择执行哪条语句。
Switch ()
{
Case 表达式1：
{
结果与1匹配时执行的语句；
Break;

}
Case 表达式2：
{
结果与2匹配时执行的语句；
Break;
}
.....
Defualt:
表达式与以上都不匹配时执行的语句；
}
常见错误：break 必须要有，default 通常在程序末尾
public class Test2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int i=1;
int gang=0;
while(i<100) {
if(i%2==1) {
gang=gang+i;

}
i++;
}
System.out.println("奇数和："+gang);
}

}

循环结构：
While
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String answer = "no";
while (answer.equals("no")) // 字符的比较
{
System.out.println("上午看书下午编程");
System.out.println("老师我合格了吗");
answer = input.next(); //输入字符不用input.nextInt
}

}
}

FOR循环
For (参数初始化；条件判断；更新循环变量){
循环操作；
}
先初始化，再进行参数判断，再执行循环体，执行完循环体后再更新参数变量。

public class For {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.print("输入学生姓名："); // 如果是println 则输入会换行
Scanner input = new Scanner (System.in);
String name = input.next();
int gang = 0;
for(int i =1;i<=5;i++) {
System.out.println("请输入第"+i+"门");
int fen = input.nextInt();
gang = gang+fen;

}
System.out.println("平均分："+gang/5);

}

}

Continue
public class For {

public static void main(String[] args) {
// TODO Auto-generated method stub

int sum = 0 ;
int i ;
for (i = 0;i<=10;i++) {
if (i==5) {
continue;
}
System.out.println(i);
}
终止本次循环直接执行下一次循环。
结果：0,1,2,3,4,6,7,8,9,10

第四章 数组
1， 声明数组
Int [] score1; int score2[], string []name
2, 分配空间
告诉计算机分配几个连续地空间
Score = new int [10]
3, 赋值
Score [0] = 1
边声明边赋值
Int [] score = new int [] {1,2,3};
import java.util.Scanner;

public class For {

public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner (System.in );
int Arrey[] = new int [] {8,4,2,1,23,34,12};
int sum = 0 ; // 数组长度用arrlength表示
for (int i =0; i<Arrey.length ; i++) {
System.out.print(Arrey[i]+" "); // 同行，用空格间隔
sum = sum + Arrey[i];
}
System.out.println("和："+sum);
System.out.println("请输入一个数：");
int num = input.nextInt();
for (int i = 0;i<=Arrey.length;i++) {

if ( num==Arrey[i] ) {
break;
}
}
System.out.println(num);
}
}
8 4 2 1 23 34 12 和：84
请输入一个数：1

1

数组的应用
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner (System.in);
System.out.print("请输入五个同学成绩："+" ");
int fen[] = new int[5];
for (int i= 0;i<fen.length;i++) {
fen[i] = input.nextInt();
}
System.out.println("排序前：");
for (int i =0 ;i<fen.length;i++)
{
System.out.print(fen[i]+" ");
}
System.out.println("排序后：");
Arrays.sort(fen); // 数组的排序
for (int i =0 ;i<fen.length;i++)
{
System.out.print(fen[i]+" ");
}
}
}

输出最后一个数组：Arr[Arr.length-1]
冒泡法排序
Int jilu = arr[0];
For (int i = 0;i<arr.length ;i++){
If（arr[i]>jilu）{
Jilu=arr[i];
}
}
任何数字和double类型做运算得出的都是double类型

循环嵌套
public class Test11 {

public static void main(String[] args) {
// TODO Auto-generated method stub
for (int i=1;i<=5;i++) {
for (int j =1;j<=i;j++) {
System.out.print("*"); //*不换行
}
System.out.println();
}
}
}

输出等腰三角形
两个相对的三角形，将一个三角形插入到另一个中，把其中一个换成空格即可
public class Test11 {

public static void main(String[] args) {
// TODO Auto-generated method stub

for (int i=0;i<=5;i++) {

for (int j=5;j>=i;j--) {
System.out.print(" ");
}
for (int j=1;j<=2*i-1;j++) {
System.out.print("*");
}
System.out.println("");
}
}
}

输出乘法表
public class Test11 {

public static void main(String[] args) {

// TODO Auto-generated method stub

for (int i =1;i<=9;i++) {
for (int j=1;j<=i;j++) {
int sum=0;
sum=i*j;
System.out.print(i+"*"+j+"="+sum+" ");

}
System.out.println(" ");
}
}
}

第五章 类和对象
类和对象
对象：描述实物的一个实体
方法：对象执行的操作
从对象中抽取的类别即类，类是抽象的概念，对象是一个看的到摸的到的具体实体。人类即类，爸爸即一个对象。

定义一个简单的类:
Class Vehicle{

Int passengers;
Int mpg;
}
再创建对象：
Vehicle v=new Vehicle();
这条语句包含了四个动作：
1， 右边的new Vehicle，是以类为模板在堆空间里创建一个对象
2， 末尾的（）表示在对象创建之后立即调用Vehicle类的构造函数对生成的对象初始化，构造函数肯定存在，如果没有写，则JAVA会有一个默认的构造函数
3， 左边是创建了Vehicle 类引用变量，所谓vehicle类引用就是以后可以用来指向vehicle对象的对象引用。
4， = 操作符使对象引用指向刚刚创建的对象
可以将这条语句拆分为下面：
Vehicle v ;
V = new vehicle();
一个类里面可以创建很多对象，如果对象连名字都没有，那我们就不能访问他们，我们只能通过对象引用间接地访问对象。
只有Vehicle v ; 时即只有引用，并没有指向对象，会被系统赋予默认值null。
对象相当于一个气球，引用变量相当于一根绳子，有了绳子我们才能轻易的抓住那个气球。一个对象引用可以指向0或1个对象，一个对象可以由N个引用指向他。
String s;
s= new String("java");
String s1 = s;
s1.append ("world");
System.out.println(s.toString());
System.out.println(s.toString());

两个打印出来的结果是一样的，s和s1仅仅是两个引用，现在两个引用指向的是一个对象，通过他们得到的也是一个对象的内容。

public class teacher{
// 属性
String name ;
String teach;
String teachage;
//方法
Public void teachstyle;
}

public class Student {

String name;
String teach;
int teachage;
public void teachstyle(){
System.out.println("大家好");
System.out.println("教授方向："+teach);
}

}

public class S1 {
public static void main(String[] args) {
//根据老师类创建一个对象wo
Student wo = new Student();
wo.name = "sun";
wo.teach = "java";
wo.teachage = 5;
wo.teachstyle();
}
}
大家好
教授方向：java

package text2;

import java.util.Scanner;

public class Youren {

String name;
int age;
public void buy() {
for (;;) { //死循环

Scanner input = new Scanner (System.in);
System.out.print("name:");
name=input.next();
if (name.equals("n")) {
break;
} //s输出为n则结束循环
System.out.print("age:");
age=input.nextInt();
if (age>=18) {
System.out.println(name+"的年龄"+age+"门票为20");

}else {
System.out.println(name+"的年龄"+age+"门票为免费");
}
}
}
}
package text2;

public class t2 {

public static void main(String[] args) {
// TODO Auto-generated method stub
Youren u=new Youren();
u.buy();

}

}
在进行面向对象编程的时候，方法和成员变量都写在具体的对象里，并对其方法和成员变量都具有很好的隐藏性，对象之间的访问都是通过接口进行的。
抽象是指在定义类的时候，确定该类的行为和动作，比如自行车可以移动，但怎么移动不进行说明。
Bike b = new Bike ();
New一个对象，该对象在内存中是存在的，用b表示对这个bike类对象的引用，使用b就能使用这个对象的数据。BIKE是类,b是引用，new bike （）是对象。
使用类时可以使用JAVA中现有的类，String s = new String ();
Java中自带String类，描述的是一个字符串。
局部变量是在方法体内创建的，能被final修饰，但不能被public ,protected,default,private,static,修饰
成员变量在堆内创建，局部变量在栈内创建。
在参数为基本类型进行传递的时候，是传递的这个值的备份，无论方法中怎么改变这个备份，都不是操作原来的数，所以原来的值是不会改变的。
用new关键字创建的对象地址是重新分配的，equals方法比较的是对象的引用，是Object类的方法。

方法的返回值
如果方法具有返回值，方法中必须使用关键字return返回该值，返回值的类型为该返回值的类型 return 表达式； 作用：跳出方法返回结果
如果方法没有返回值，则返回值类型为void

方法之间允许互相调用，不需要知道方法的具体实现，实现重用提高效率

public class Ceshi {
public void a () {

}
public void b () {
a(); // 在b中调用a
}
}
不同类之间的调用需要new一个对象，同一类之间可以直接进行调用
方法之间不能相互钱傲定义
不能在方法外部写逻辑代码，逻辑代码只能写到方法里面

public class Ceshi {
int java ;
int c;

int DB;
public int zong () {
return java+c+DB ;
}
}
public class t2 {

public static void main(String[] args) {
// TODO Auto-generated method stub
Ceshi t= new Ceshi();
Scanner input = new Scanner(System.in);

t.c=input.nextInt();
t.DB=input.nextInt();
t.java=input.nextInt();
System.out.println("zong:"+t.zong());

}

}

输出总成绩
成员变量和局部变量
变量声明的位置决定变量作用域
变量作用域确定可在程序中按变量名访问该变量的区域

JAVA会给成员变量一个初始值，但不会给局部变量初始值
不同的方法可以定义同样的变量

封装
人机猜拳
分析业务，抽象出类和类的行为和特征，创建用户类

Person.java
package caiquan;
import java.util.Scanner;
public class Person {

String name;
int fen;
Scanner input = new Scanner(System.in);
public void setName() { //设置姓名

System.out.println("请输入你的姓名：");
name= input.next();
}
public int chu() {
System.out.println("请出拳：1，石头，2.剪刀3.布");
int choose ;
choose = input.nextInt();
switch (choose) {
case 1:
System.out.println("你出拳为石头");
break;
case 2:
System.out.println("你出拳为剪刀");
break;
case 3:
System.out.println("你出拳为布");
break;
}
return choose;

}

}
Computer.java

package caiquan;

import java.util.Scanner;

public class Computer {
String name ;
int fen ;
Scanner input = new Scanner(System.in);
public int setName() {
System.out.println("请选择角色：1，张三2，李四3，王五");
int choose;
choose = input.nextInt();
switch (choose) {
case 1:
name="张三";
break;
case 2:
name = "李四" ;
break;
case 3:
name = "王五";
break;

}
return choose;

}
public int chu () {
int choose = (int)(Math.random()*3);
switch (choose){
case 0:
System.out.println(name+"出拳为石头");
break;
case 1:
System.out.println(name+"出拳为剪刀");
break;
case 2:
System.out.println(name+"出拳为布");
break;
}
return choose+1;
}

}

Game.java
package caiquan;

import java.util.Scanner;

public class Game {
Scanner input =new Scanner (System.in);
public void start() {
Person p=new Person();
Computer c = new Computer();
System.out.println("\t*********************");
System.out.println("\t***猜拳开始***");
System.out.println("\t*********************");
System.out.println("出拳规则：1，石头 2，剪刀 3，布");
c.setName();
p.setName();
System.out.println(c.name+ "vs"+p.name);
//没有固定的循环次数，使用while ，对y ,n 不用做其他处理
System.out.println("是否要开始吗？");
String answer= input.next();
int ci=0;
while(answer.equals("y")) {
ci++;
int pquan=p.chu();
int cquan=c.chu();
if((pquan==1&&cquan==2)||(pquan==2&&cquan==3)||(pquan==3&&cquan==1)) {
System.out.println(p.name +"win");
p.fen ++;
}else {
if((pquan==1&&cquan==1)||(pquan==2&&cquan==2)||(pquan==3&&cquan==3)) {

System.out.println("平局");

}else {
System.out.println(c.name+"win");
c.fen++;
}

System.out.println("是否进入下一轮：");
answer= input.next();

}

}
System.out.println("--------------------");
System.out.println("对战次数："+ci);
System.out.println(p.name+"分数为"+p.fen);
System.out.println(c.name+"分数为"+c.fen);
}

}

text.java
package caiquan;

import java.util.Scanner;

public class Test {
public static void main (String[]args) {
Game u = new Game ();
u.start();
}

}

*********************
***猜拳开始***
*********************
出拳规则：1，石头 2，剪刀 3，布
请选择角色：1，张三2，李四3，王五
3
请输入你的姓名：
ee
王五vsee
是否要开始吗？
y
请出拳：1，石头，2.剪刀3.布
1
你出拳为石头
王五出拳为石头

平局
是否进入下一轮：
y
请出拳：1，石头，2.剪刀3.布
2
你出拳为剪刀
王五出拳为剪刀
平局
是否进入下一轮：
y
请出拳：1，石头，2.剪刀3.布
3
你出拳为布
王五出拳为剪刀
王五win
是否进入下一轮：
n
--------------------
对战次数：3
ee分数为0
王五分数为1

类的带参方法

参数的传递：
JAVA中传递任何东西都是值传递，且只有这一种参数传递方式，如果传入方法是基本类型或引用的东西，就得到此基本类型或引用的一份拷贝。

定义带参的方法：形参必须要有数据类型

调用带参类型方法：实参，传入值，不带数据类型。
public class t1 {
public String A(String name) {
String newStr= name+"!";
return newStr;
}
}

public class t2 {

public static void main(String[] args) {
// TODO Auto-generated method stub

t1 A = new t1();
String name = " hello "; //将hello传入t1中去
name = A.A(name); //在对象A中调用A方法
System.out.println(name);

}

}

可以带多个参数，注意他们的顺序和数据类型即可。

用包组织程序
解决类的同名问题相当于一个文件夹
建立工程，建立一个类，在类中选择加入到哪个包
包名由小写字母组成，不能以原点开头或者结尾。创建了包cn.b.shuguo即创建了目录cn/b/sunguo
使用不在同一包中的类需要import，创建一个包就要引入一个包。inport java.util.*表示导入java.util包中所有的类。
Inport包名.aaa表示引入该包下的aaa类，import语句要在packet语句后使用。

练习

package com.bank;
import static java.lang.System.out;

import java.util.Scanner;
public class Account {
int money = 0;
public void start() {

Scanner input = new Scanner(System.in);

while(true) {
out.println("1存款 2取款 3退出");
out.println("请选择要办理的业务：");

switch(input.nextInt()) {
case 1:
out.println("请输入存款金额");
int jin = input.nextInt();
cun(jin);
break;
case 2:
out.println("请输出取款金额：");
jin=input.nextInt();
qu(jin);
break;
case 3:
out.println("谢谢使用再见");
return ; // break是跳出switch循环，return是终止整个方法
}

out.println("余额为："+money);
}

}
public void cun(int jin) {

money+=jin;
out.println("存款成功");
out.println();

}
public void qu(int jin) {
if(money>=jin) {
money-=jin;
out.println("取款成功");
out.println();
}else {
out.println("余额不足");
}

}
}
//存钱

package com.bank;

public class text {

public static void main(String[] args) {

// TODO Auto-generated method stub
Account ac = new Account();
ac.start();
}

}
1存款 2取款 3退出
请选择要办理的业务：
1
请输入存款金额
100
存款成功

余额为：100
1存款 2取款 3退出
请选择要办理的业务：
2
请输出取款金额：
100
取款成功

余额为：0
1存款 2取款 3退出
请选择要办理的业务：
3

谢谢使用再见

字符串
使用String对象存储字符串，String位于java.lang包中具有丰富的方法：计算字符串长度，比较字符串，连接字符串，提取字符串等。
Str.length() 可用于计算字符串长度，即字符串的字符的个数。汉字一个算是一个字符
判断字符串是否一致使用equals()方法，==判断的是两个字符串的内存位置，判断两者是否为同一对象。

判断.java文件名是否正确，判断邮箱格式是否正确
分析：合法的文件名应该以.java结尾。合法的邮箱名至少要包含“@”，“.”，并检查@是否在.之前。

public class