1.break和continue区别
使用场合：
break可用于switch结构和循环结构中。
continue只能用于循环结构中。
作用：
break语句终止某个循环，程序跳转到循环块外的下一条语句中。
continue跳出本次循环，进入下一次循环。
package qufen;
import java.util.*;//相当于导入了所有Java.util下的所有包。
public class Over {
public static void main(String[] args){
Scanner in=new Scanner(System.in);
while(true){
System.out.println("请输入你的密码：");
int password=in.nextInt();
if(password!=428)
continue;//结束该句后，执行下一次循环。
else break;//结束，直接跳出循环。
}
System.out.println("密码正确。");}
}
package qufen;
import java.util.*;//相当于导入了Java包。
public class Over {
public static void main(String[] args){
while(true){
Scanner in=new Scanner(System.in);
System.out.println("请输入年份：");
int year=in.nextInt();
System.out.println("请输入月份：");
int month=in.nextInt();
int sum=0;
for(int i=1900;i<=year-1;i++){
/*计算某天星期几，算出现在时间和1900年的时间差，总时间%7即求得星期几
* 总时间先求出从1900到前一年年末的时间然后加上这一年时间
*
*/
if(i%4==0&&i%100!=0||i%400==0)//判断是否是闰年
sum+=366;
else
sum+=365;
}
for(int i=1;i<=month-1;i++){
if(i==2){
if(year%4==0&&year%100!=0||year%400==0)
sum+=29;
else
sum+=28;
}
else{
if(i==4||i==6||i==9||i==11)
sum+=30;
else
sum+=31;
}
}
int day;
/*
* 判断某个月有多少天*/
if(month==2){
if(year%4==0&&year%100!=0||year%400==0)
day=29;
else
day=28;
}
else{
if(month==4||month==6||month==9||month==11)
day=30;
else
day=31;
}
sum+=1;
int week=sum%7;
System.out.println("日\t一\t二\t三\t四\t五\t六");
for(int j=1;j<=week;j++){
System.out.print("\t");//通过取余求出所需空的格数
}
for(int m=1;m<=day;m++){
if(sum%7==6){
System.out.print(m+"\n");//如果星期六则需要换行
}else{
System.out.print(m+"\t");
}
sum+=1;
}
System.out.println();
System.out.println("\n是否继续查询（yes or no）：");
String p=in.next();
String s="yes";
if(p.equals(s))/*
比较两者是否相等，==比较时要地址相同
equals比较规则为：如果两个对象的类型一致，并且内容一致，则返回true,这些类有：
java.io.file,java.util.Date,java.lang.string,包装类（Integer,Double等）
*/ continue;
else
break;
}
}
}
package lei;
class Fu
{
int num=5;
static int numS=6;
void method1()
{
System.out.println("f1");
}
void method2()
{
System.out.println("f2");
}
static void method4()
{
System.out.println("f4");
}
}
class Zi extends Fu
{
int num=8;
static int numS=9;
void method1()
{
System.out.println("z1");
}
void method3()
{
System.out.println("z3");
}
static void method4()
{
System.out.println("z4");
}
}
class Test
{
public static void main(String[] args)
{
//- - - - - - - - - - - - - - - - -
//例1：继承
//Zi z=new Zi(); //本类引用指向本类对象
//z.method1(); //Zi类复写method1，返回z1
//z.method2(); //Zi类继承Fu类method2，返回f2
//z.method3(); //Zi类特有method3，直接返回z3
//- - - - - - - - - - - - - - - - -
//例2：多态
//Fu f=new Zi(); //父类引用指向子类对象
//f.method1(); //Zi类复写method1，返回z1
//f.method2(); //Zi类继承Fu类method2，返回f2
//f.method3(); //Fu类没有method3，编译失败
//- - - - - - - - - - - - - - - - -
//例3，面试
//Fu f=new Zi();
//System.out.println(f.num); //先在Fu类找num属性，直接返回5
//Zi z=new Zi();
//System.out.println(z.num); //先在Zi类找num属性，直接返回8
//- - - - - - - - - - - - - - - - -
//例4，面试
//Fu f=new Zi();
//f.method4(); //先在Fu类找methdo4，返回f4
//Zi z=new Zi();
//z.method4(); //先在Zi类找methdo4，返回z4
//- - - - - - - - - - - - - - - - -
//例5，面试
//Fu f=new Zi();
//System.out.println(f.numS); //先在Fu类找numS，返回6
//Zi z=new Zi();
//System.out.println(z.numS); //先在Zi类找numS，返回9
}
} class Person {
public static void prt(String s) {
System.out.println(s);
}
Person() {
prt("A Person.");
}
Person(String name) {
prt("A person name is:" + name);
}
}
public class Chinese extends Person {
Chinese() {
super(); // 调用父类构造函数（1）
prt("A chinese.");// (4)
}
Chinese(String name) {
super(name);// 调用父类具有相同形参的构造函数（2）
prt("his name is:" + name);
}
Chinese(String name, int age) {
this(name);// 调用当前具有相同形参的构造函数（3）
prt("his age is:" + age);
}
public static void main(String[] args) {
Chinese cn = new Chinese();
cn = new Chinese("kevin");
cn = new Chinese("kevin", 22);
}
}
结果为：A Person.
A chinese.
A person name is:kevin
his name is:kevin
A person name is:kevin
his name is:kevin
his age is:22
在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。
super后加参数的是用来调用父类中具有相同形式的构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。
当然，在Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你可以将它替换为“this.prt”
(因为它继承了父类中的那个方法）或者是“super.prt”（因为它是父类中的方法且可被子类访问），它照样可以正确运行。但这样似乎就有点画蛇添足的味道了。super和this的异同：
1)super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）
2)this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
3)super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）
4)this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）
5）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
6）super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。
7）super()和this()均需放在构造方法内第一行。
8）尽管可以用this调用一个构造器，但却不能调用两个。
9）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
10）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
11）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。5多态
package h；
public class fg{
public static void main(String[] args){
//向上类型转换
Cat cat = new Cat();
Animal animal = cat;
animal.sing();//向上类型调用的也是子类方法
//向下类型转换
Animal a = new Cat();
Cat c = (Cat)a;
c.sing();
c.eat();
//编译错误
//用父类引用调用父类不存在的方法
//Animal a1 = new Cat();
//a1.eat();
//编译错误
//向下类型转换时只能转向指向的对象类型
//Animal a2 = new Cat();
//Cat c2 = (Dog)a2；
}
}
class Animal
{
public void sing()
{
System.out.println("Animal is singing!");
}
}
class Cat extends Animal
{
public void sing()
{
System.out.println("Cat is singing!");
}
public void eat()
{
System.out.println("Cat is eating!");
}
}
/*结果：Cat is singing!
Cat is singing!
Cat is eating!
*/
/*面向对象的三大特性：封装、继承、多态。
多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
* 多态存在的三个必要条件
一、要有继承；
二、要有重写；
三、父类引用指向子类对象。
* */ //获取某个字符串出现次数
String s = "sdsjavajdhsjajavajsdhjavdjava99;[javahdsjava";
String m = "java";
int count = 0;
int index = -1;
while(s.indexOf(m)!=-1){
index = s.indexOf(m);//获取指定字符串第一次出现的索引，如一开始index = 3；
s=s.substring(index + m.length());//返回一个新字符串
count++;
}
System.out.println(count);
}
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
