JAVA结构
Java控制结构
if…else…选择结构
if(条件) {…}
if(条件) {…} else {…}
if(条件) {…} else if(条件) {…} else {…}
switch…case… 选择结构
switch(表达式)
{case 值1:……;break;
case 值2:……;break;
case 值3:……;break;
default:……;}
注意：
1）值1、值2、值n是条件，switch的值符合值n就走值n的语句
2）break为中断并跳出循环，不加break则会在满足值n的条件之后继续无视case条件直接向后执行语句
3）default等同于if条件语句中的else
Java循环结构
for循环
for(int i=1;i<101;i++)
分析：此语句表示i从1开始循环100次，每次自增1（再前一次的结果上自增1），
i<101为循环次数判断条件，小于101表示循环至100结束，所以i的结果是100
注意：for循环可以是死循环，实际中死循环是禁止的，会导致程序进入假死状态（一直循环无法得到结果，只能强制结束）
while循环
int i=1； while(i<101) {i++;}
分析：语义同上方for语句，i的结果也是100
注意：while循环只循环{}中的执行一次，结果再判定并执行循环一次直至条件失效
do…while…循环
int i=1; do {i++} while(i<101)
分析：do……while……为先执行后判定，即先i++，再判定i<101，所以最终结果是判定i=100满足i<101后会i++，此时i的值是101,101不满足i<101循环结束，i的结果是101。
注意：do…while…循环区别于for循环和while循环，先执行再判定，所以{}中的语句至少会被执行一次
JAVA重要理论
类与对象
类：类是对对象的虚拟化设计，是具有相似或相同属性的实物、对象的统称，是抽象概念。如车于自行车、轿车、卡车，车就是一个类
对象：实物、实例，看得见摸得着，是可以具象化的真实存在的东西
属性：直观的、可见的或可测量的特性，如颜色、大小、重量等
方法：动作，对象或者类可以用来干什么，比如红色的车可以开门、升降车窗，红色是车的属性，开门、升降车窗就是方法
对象修饰符
public 公共的
1）开放权限，任意对象或子对象均可访问
2）除修饰方法和属性外，也修饰类，若类无public修饰，则仅同一包中可见
protected 受保护的
1）不加修饰默认为protected，仅对同一包内成员开放权限
private 私有
1）只有此类本身具有访问权限，即使它的实例也无法访问该private属性或方法
2）核心代码或者算法或者高危操作，出于保护的考虑不让随意调用，使用此修饰
对象的产生与构造函数
对象的产生格式（对象的实例化）
类名 对象名=new 类名();
解析：
1）类名必须与要实例化的类名一致
2）对象名是自定义的，不能与关键字、类名一致
3）=new和();是固定写法，不可变更
构造方法：
1）构造方法中的类名与class的继承类名必须一致
2）构造方法的声明处不能有任何返回值类型的声明
3）不能在构造方法中使用return返回一个值
例：public class wuziqi extends gameMap //子类wuziqi继承父类gameMap
{public void gameMap(int heng,int shu){}} //定义一个gameMap的构造方法并给定两个整型变量heng和shu
类的继承
继承的概念：类的属性可以被对象继承，被继承的类称超类（或父类，或基类），继承的对象称为子类（或继承类）
java中的继承：
1）java中使用关键字extends表示继承，
如：public class wuziqi extends gameMap //子类wuziqi继承父类gameMap
2）被继承的类叫超类（SuperClass），继承超类的叫子类（SubClass）
3）一个子类只能继承自一个超类，子类同时可以成为其他类的超类，参见生物学上的纲目科属种
4）超类中private修饰的属性或方法不能被子类使用
5）超类和子类均是独立的类，可以分开调用而不受继承关系影响
方法的覆盖与重载
覆盖（覆写Override，这是英文释义，不是关键字！！！）
1）定义：超类和子类中定义的完全一致的两个方法，子类方法会覆写超类，即调用该方法时只使用的是子类的方法中的内容
2）完全一致指权限一致（非private），参数类型、个数、顺序都一致
3）超类或子类的方法如果是static静态的，则不能覆写
重载（Overload这还是英文释义，不是关键字！！！）
1）定义：与继承无关，只是在某一个类的内部，同名不同参数的方法称为重载，重载的方法都可以使用（使用时带的参数不一样）
2）不同参数包含：参数类型不一致；参数个数不一致；参数顺序不一致。不区分同类型不同参数名，比如abc(int m,int n){}与abc(int n,int m){}不属于重载
抽象类与接口
抽象类
1）定义：抽象化并集合某一或对个对象具有的相同属性或方法的类
2）抽象类不能被实例化，只能被继承
3）抽象类使用关键字abstract来声明：abstract class 类名
例：public abstract class shouji
{
String yanse=“red”;
public abstract void kaiji();//不用写方法的具体内用，那是开发的工作
public abstract void guanji();
}
4）抽象类多用于团队内部的系统架构师给开发写系统框架，开发根据写好的框架编码实现具体的方法，以此规范和简化编程
接口
1）接口用于不同开发团队之间的协调，定义一系列的规范，便于不同开发团队的一致性，虽然接口中定义的方法与抽象类相似，都不做实现，只声明用途，但其抽象程度高于抽象类，且更灵活
2）接口使用关键字interface：interface 接口名
3）接口需要具体的类来实现，否则没有意义
public interface suanfa {
public void jiafa(int a,int b);
public void jianfa(int a,int b);}
4）实现接口：class 类名 implements 接口名
public class jisuanqi implements suanfa {
public void jiafa(int a,int b)
{System.out.println(a+b);}
public void jianfa(int a,int b)
{System.out.println(a-b);}}
5）接口中的方法必须全部实现
多态
1）定义：一个类可以是另一个类的对象（或者一个子类可以是另一类的父类）
2）多态与重载：
a.多态是个运行时问题，体现在调用不同类的相同方法时，只有在调用出结果之后才能确定方法来自哪个类
b.重载是个编译时问题，体现在同一个子类内部，编译文件取用同名不同参数的方法
JAVA代码示例
以下代码截取自eclipse继承运行环境，做了大量修改，不可直接还原至eclipse中！！！
数据类型的使用
boolean 布尔类型
布尔类型的数据，只能存放true和false,一般用于判断语句或则执行结果
例： boolean truth = true;
System.out.println(truth);
char 字符类型
1）字符类型的变量只能存一个字符，并且只能是单引号的,比如性别就是用字符类型
例： char ch = ‘中’;
System.out.println(ch);
2）char c=97;//此处的97是ASCII，键盘上的每个键都对应一个ASCII，更多信息详询度娘
System.out.println©;
String 字符串类型（注意S必须大写）
字符串类型的变量可以存一个或则多个，并且用的是双引号，比如登录用户名就是字符串类型
例： String chuan=“asdhask12312中文！！！”;
System.out.println(chuan);
整型byte、short、int和long
整型类型有4个，一般用于数字类的计算或则逻辑处理，比如计算余额等。
byte b = 127; 8位整数
short s = 32767; 短整型，16位整数
int i = 2147483647; 整型，32位整数
long l = 9223372036854775807L; 长整型，64位整数，末尾的L声明这是一个长整型数
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
浮点型float和double
浮点类型（小数类型）,float单精度浮点型范围较小为32位，double双精度浮点型64位
float f = 99887766.554433f;
double d = 99887766.5544332211;
System.out.println(f);
System.out.println(d);
数据类型转换
1）整数类型之间转换:byte->int,int->long，小转大是完全兼容，直接用，大转小可能会有问题，不建议使用。
byte by=127;
int iy=by;
System.out.println(iy);
long ly=iy;
System.out.println(ly);
2）整型转字符串类型的方法
int ist=99999999;
String st=“你的余额是：”+ist+“元。”;
System.out.println(st);
3）整型转字符类型，使用 “”+变量名 的方式
int i2=123456789;
String s1=""+i2;
System.out.println(s1);
4）纯数字型的字符串转整型使用Integer.parseInt()转换
String st1=“1234”;
int ist1=Integer.parseInt(st1);
System.out.println(ist1);
5）强制转换，浮点型转整型只保留整数部分，不作四舍五入
double d1 = 12345.678;
int i1=(int)d1;
System.out.println(i1);
运算符的使用
一元运算符自增++和自减–
int jiajia=1;
int jianjian=2;
jiajia++这种运算优先级比较低,如果遇到有输出的情况下，是先进行输出的，然后jiajia才自增1
++jiajia这种运算优先级非常高，如果遇到有输出的情况下，是先自增1，然后再输出的。
System.out.println(++jiajia); 先++
System.out.println(jiajia++); 先打印，后++
二元运算符取余，就是两个数相除，不要除尽，就取除不尽的值即可，如果能除尽就是0
1）对10取余
int eryuan=10;
System.out.println(eryuan%2);
2）给定整型数字是1234，要求分别输出这个整型的个位，十位，以及百位和千位的数字。
int shuzi=1234;
int qianwei=shuzi/1000;//千位
int baiwei=(shuzi%1000)/100;//百位
int shiwei=(shuzi%100)/10;//十位
int gewei=(shuzi%10);//个位
System.out.println(“千位是：”+qianwei+" 百位是："+baiwei+" 十位是："+ shiwei+" 个位是："+gewei);
唯一的三元运算符?:
三目元运算?: ?前面是条件，:前后分别为结果1和结果2，如果为真返回结果1，如果为假返回结果2
1）布尔类型b1如果等于a1的值100，则返回值true，否则返回值false
int a1=100;
boolean b1=a1100?true:false;
System.out.println(b1);
2）如果你手上有零钱，就买一个苹果，如果没有就买个西瓜。
String lingqian=“没有零钱”;
String zenmezuo=lingqian"有零钱"?“我买了一个苹果”:“我买了一个西瓜”;
System.out.println(zenmezuo);
3）比如我们在坐火车前检票，要出示身份信息，只要不是外国人就得出示身份证，如果是外国人就出示护照。
String guoji=“中国人”;
String zhengjian=guoji!=“外国人”?“出示身份证”:“出示护照”;
System.out.println(zhengjian);
boolean chinese=false;
String st3=chinese!=false?“出示身份证”:“出示护照”;
System.out.println(st3);
逻辑与运算&&
1）&&并且 ，比如我们到了餐馆里点菜，你有没有钱？菜品好不好吃？饿不饿？
String i3=“有钱”;
String j=“好吃”;
String k=“饿”;
String a=i3==“有钱”&&j==“好吃”&&k==“饿”?“点菜”:“走人”;
System.out.println(a);
逻辑或运算
1）||或则，比如我同时喜欢了两个女神 ，现在我要对着2个女神同时表白，如果两个女神同时答应我，输出一句我有女朋友了，如果只有其中一个女神答应我呢？我也输出一句我有女朋友了,如果两个女生都拒绝我，我就输出我还是个单身狗。
String t1=“两人都答应”;
String t2=“任意一个人答应”;
String t3= t1==“两个人都答应”||t2==“任意一个人答应” ?“我有女朋友了”:“我还是单身狗”;
System.out.println(t3);
位与&运算
位运算符，与&,计算方法：先转换为2进制，然后相同位子的2个数进行相与，
所谓的与就是0&0=0,0&1=0,1&0=0,1&1=1
int src=15; //1111
int dst=11; //1011
System.out.println(src&dst);//1011，答案是11
位或|运算
位运算符,或|,计算方法：先转换为2进制，然后相同位子的2个数进行或
所谓的或就是0|0=0,0|1=1,1|0=1,1|1=1
System.out.println(src|dst);//1111,答案是15
赋值运算符
1）uzhi+=2;就等同于fuzhi=fuzhi+2;
int fuzhi=10;
fuzhi=fuzhi+2; 或者fuzhi+=2;
System.out.println(fuzhi);
2）要求使用赋值运算符，fuzhi-2，输出结果应该是8
fuzhi-=2; 减2
System.out.println(fuzhi);
3）fuzhi%=2; 除2取余
数组
1）定义：一维字符串数组,按照想象理解为一条3+2的里面有多个饼干。
String[] shuzu={“asd”,“sdsadsa123”,“asd21”,“中文”};
System.out.println(shuzu[3]);
2）一维整型数组,请你分别输出zxshuzu的第一个元素是2，第二个元素是18，第三个元素是12，第四个元素是6
int[] zxshuzu={2,18,12,6};
System.out.println(“zxshuzu的第一个元素是”+zxshuzu[0]);
System.out.println(“zxshuzu的第二个元素是”+zxshuzu[1]);
System.out.println(“zxshuzu的第三个元素是”+zxshuzu[2]);
System.out.println(“zxshuzu的第四个元素是”+zxshuzu[3]);
3）使用循环给数组赋值并打印二维数组的值55
int[][] erwei=new int[5][5];
for(int a1=0;a1<5;a1++){for(int b1=0;b1<5;b1++){erwei[a1][b1]=a1b1;}}
for(int a1=0;a1<5;a1++){for(int b1=0;b1<5;b1++){System.out.print(erwei[a1][b1]+" ");} System.out.println();}
解析：第一个for嵌套循环赋值，第二个for嵌套循环打印
if…else…选择结构
1）早上来了之后，我问你吃了吗？你如果吃了，你就说一声你吃了，如果你没吃，也说一下你没吃。
boolean chilema=false;
if(chilematrue){System.out.println(“我吃了。”);}
else{System.out.println(“我没吃。”);}
2）如果你有10万就买个桑塔纳，如果你有20万，买个凯美瑞，如果你有30万，就买个奥迪，否则就别买了。
int cunkuan=1234567;
if(cunkuan<200000 && cunkuan>=100000){System.out.println(“桑塔拉”);}
else if(cunkuan<300000 && cunkuan>=200000){System.out.println(“凯美瑞”);}
else if(cunkuan>=300000){System.out.println(“奥迪”);}
else{System.out.println(“别买了”);}
switch…case… 选择结构（理论参加第5页JAVA结构）
1）写给字体变化颜色，如果我输入的是1，字体显示为红色，如果我输入的是2，字体显示为绿色，如果我输入的是3，字体显示为黄色，其他情况都是默认的黑色。
int yanse=2;
switch(yanse){
case 1:System.out.println(“字体颜色是红色。”);break;
case 2:System.out.println(“字体颜色是绿色。”);break;
case 3:System.out.println(“字体颜色是黄色。”);break;
default:System.out.println(“字体颜色是默认黑色。”);}
for循环
1）从1加到200，如果he这个变量的值超过了10000了，就别加了，然后输出当前he的结果
int he=0;
for(int i=1;i<201;i++)
{if(he>10000){break;}he=he+i;}System.out.println(he);
2）请用循环处理，用输出一个直角三角形
方法一：嵌套循环
int m,n;
for(m=1;m<5;m++){for(n=1;n<=m;n++){System.out.print("");}System.out.println();}
方法二：循环打印
for(int n=1;n<5;n++){
if(n1){System.out.println("");}
else if(n2){System.out.println("**");}
else if(n3){System.out.println("");}
else if(n==4){System.out.println("");}}
3）请用for循环处理，用输出等腰直角三角形
for (int i = 1; i < 5; i++) {
for (int j = 1; j < 8; j++) {if (j <= 4 - i || j >= 4 + i) {System.out.print(" “);}
else {System.out.print(”");}}
System.out.println();}
while循环
1）从1加到10，然后输出当前he的结果
he=0;
int i2=0;
while(i2<101){he=he+i2; i2=i2+1;}System.out.println(he);
2）请用while语句写出一个直角三角形
int i=1;
while(i<=4){int j=1;while(j<=i){System.out.print("*");j++;}System.out.println();i++;}
do while用法
int i3=1;
do{if(i3==1){System.out.println("*");}
else if(i3==2){System.out.println("**");}
else if(i3==3){System.out.println("***");}
else if(i3==4){System.out.println("****");}
i3++;}while(i3<5);
continue是跳出本次循环，继续下次循环
break是跳出循环结束循环。
for(int i=1;i<4;i++){if(i2){System.out.println("i2");continue;}System.out.println(i);}
作业示例
1.打印如下图形
*
**
int b=1;
do{
int a=1;
while(a<=b){
System.out.print("");
a++;
}
System.out.println();
b++;
}while(b<=5);
2.打印99乘法表
int b=1;
do{
int a=1;
while(a<=b){
System.out.print(a+""+b+"="+ab+" ");
a++;
}
System.out.println();
b++;
}while(b<=9);
3.将下列一组数按照从小到大的顺序输出(冒泡排序):9,12,55,2,5,20
int b[]=new int[]{9,12,55,2,5,20};
int i=b.length;
for(int a=0; a<i-1;a++)
{
for(int c=a+1;c<i;c++){
if(b[a]>b[c]){
int d;
d=b[a];
b[a]=b[c];
b[c]=d;
}
}
}
System.out.println(Arrays.toString(b));
int a []={9,12,55,2,5,20};
int b;
for(int c=0;c<a.length-1;c++){
for(int d=0;d<a.length-1-c;d++){
if(a[d]>a[d+1]){
b=a[d];
a[d]=a[d+1];
a[d+1]=b;
}
}
}
System.out.print("{");
for(int c=0;c<a.length;c++){
System.out.print(a[c]);
if (c < a.length - 1){
System.out.print(",");}
}
4.使用循环给数组赋值并打印数组的值
Scanner sc=new Scanner(System.in);
System.out.println(“数组的长度是：”);
int b=sc.nextInt();
int t,s;
int c[]=new int[b];
for(int a=0;a<b;a++){
s=a+1;
System.out.println(“请输入第”+s+“个数：”);
c[a]=sc.nextInt();
}
for(int d=0;d<b;d++){
for(int e=0;e<b-1-d;e++){
if(c[e]>c[e+1]){
t=c[e];
c[e]=c[e+1];
c[e+1]=t;
}
}
}
System.out.println("冒泡排序后输出数组为：");
for(int f=0;f<b;f++){
System.out.println(c[f]);
}
}
}
用Java语言实现下列题目:
1.输入50个数,统计其中有多少个正数,多少个负数?
Scanner sc = new Scanner(System.in);
System.out.println(“输入数的个数：”);
int a = sc.nextInt();
int t, m = 0, n = 0;
for (int b = 1; b <= a; b++) {
System.out.println(“输入的第” + b + “个数是：”);
t = sc.nextInt();
if (t > 0) {
m = m + 1;
} else if (t < 0) {
n = n + 1;
}
}
System.out.println(“正数个数为：” + m + “个,” + “负数个数为：” + n + “个”);
编写一个车类Car,属性和方法自定义
public class car {
private String color;
private String type;
public String high;
public void setColor(String a){
color=a;
}
public String getColor(){
return color;
}
public car() {
System.out.println(“我是car！”);
}
写一个车类的子类Bike,属性和方法自定义
public class bike extends car{
public String zuodian;
public String caizhi;
public void chezhe(String b){
caizhi=b;
System.out.println(caizhi);
}
public bike(){
super();
System.out.println(“我是bike！”);
}
编写测试类TestBike
public class testCarhbike {
public static void main(String[] args) {
// TODO Auto-generated method stub
bike bi = new bike();
bi.high = "150";
System.out.println(bi.high);
bi.zuodian = "皮和钢";
System.out.println(bi.zuodian);
bi.chezhe("皮质和钢材");
bi.setColor("red");
System.out.println(bi.getColor());
}
}
953
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
