java学习1 -基础练习笔记
> java语言基础
a=9
b=12 a=10
c=13 a=11
public class ScoreTest{
public static void main(String args[]){
Scanner sc =new Scanner (System.in);
System.out.println("请输入成绩");
int score =sc.nextInt();
switch(int)(score/10){
case 10: System.out.println("成绩为优");break;
case 9:System.out.println("成绩为优");break;
....
default:System.out.println("成绩为差!");
}
}
}
public class GetSum{
public static void main (String[] args){
int x =1;
int sum =0;
while (x<=10000){
sum=sum+x;
x++;
}
System.out.println(sum);
}
}
public class Sum{
public static void mian (String[] args){
int i=1;
int sum=0;
while(i<10000){
if(x%2==0 &&x%3==0){
sum=sum+x;
}
x=x+1;
}
System.ou.println(sum);
}
}
pubic class PasswordDemo{
pubic static void main (String[] args){
Scanner input= new Scanner(System.in);
String realPassword ="123", password="";
do{
System.out.println("请输入密码");
password=input.next();
}while(!password.equals(realPassword));
System.out.println(登陆成功);
}
}
public class Multiple{
public void main (String[] args){
for(int i=1,i<=9,i++){
for(int j=1 ,j<=9,j++){
int a=i*j;
SyStem.out.println(i+"x"+j+"="+a);
}
}
}
}
public class ContinueDemo{
public static void main(String[] args){
int i=1;
while (i<100){
if(i%3==0){
continue;
}
System.out.println(i+" ");
i++;
}
}
}
public class ReturnTest{
public static double area(double a,double b){
return (a*b);
}
public static void main(String[] args){
System.out.println("面积是“+area(1.5,2.5))
}
}
int a[][];
a=new int [3][4];
a[0]=new int [3];
a[1]=new int [4];
a[2]=new int [1];
> 面向对象编程
**面向对象的基本特征:抽象、封装、继承、多态**
抽象是根据业务需要,把客观世界的事物中与业务相关的特征和行为归纳总结出来、忽略与本业务无关的特征和行为,从形成类的过程。
继承是类之间的一种代码重用机制。如果A类继承了B类,则A类拥有了B类的除了私有属性和私有方法外的所有属性和方法,同时可以添加自己特有的属性和方法。
多态是实现接口的多个类或一个父类的多个子类有相同的方法名,但是具有不同的表现方式。
**类修饰符包括:public、缺省、abstract、final**
public class Account{
private String number,name;
private double yue;
private Date b_time;
public void setNumber(String nb){
this.number=nb;
}
public String getNumber(){
return number;
}
public void setName(String n){
this.name=n;
}
public String getName(){
return name;
}
public void setyue(double yue){
this.yue=yue;
}
public double getyue(){
return yue;
}
public void setbTime(Date t){
this.b_time=t;
}
public Date getbTime(){
return b_time;
}
public Account(){
this.number="";
this.name="";
this.yue=0;
}
public Account(String number,String name,double yue){
this.number=number;
this.name=name;
this.yue=yue;
}
public void saveMoney(double a){
this.yue+=a;
}
public void takeMoney(double a){
if(this.yue<a){
System.out.println("余额不足");
return;
}
this.yue-=a;
}
public void change(Account other,double a){
if(this.yue<a){
System.out.println("余额不足,不可以转账");
}else{
other.yue+=a;
this.yue-=a;
}
}
}
public class AccountManager(){
public static void mian(String[] args){
Account zhangsan=new Account("001","张三",1000);
Account lisi =new Account("002","李四",300);
zhangsan.saveMoney(500);
lisi.saveMoney(500);
zhangsan.takeMoney(200);
zhangsan.change(lisi,300);
zs=zhangsan.getyue();
ls=lisi.getyue();
System.out.println("张三的余额是:"+zs+",李四的余额是:"+ls);
}
}
return是表示此函数执行完毕;break表示推出循环,continue表示略过本次循环继续下一个循环
> 继承
**所谓继承,是指子类从它的父类中继承可访问的数据成员和方法,是一种代码重用的手段。**
**子类中自动拥有了父类中定义的变量和方法,不需要再重新定义,只需要定义子类自己独有的属性和方法即可。**
**父类中定义成了private的属性变量,在Student类中不可见,不能直接使用,只能通过继承过来的相应的get、set方法来访问父类中定义的私有属性变量。子类可以继承父类中除了private属性以外所有的属性变量。但子类对象的内存中是有父类中定义的私有变量的。**
**子类继承父类时,需要注意以下三点:**
(1)在子类继承父类的时候,子类的构造方法必须调用父类的构造方法;
(2)如果父类有默认无参数构造方法,子类实例化时会自动调用.如果父类没有默认无参数构造方法,子类构造方法必须显式的通过super调用父类的有参数构造方法;
(3)子类不能继承父类的构造方法,只能调用父类的构造方法。而且必须调用父类的构造方法,调用语句必须写在子类构造方法的第一行。
**子类对象的属性和方法实际上包括两部分:**
在父类定义的,可以用super(父类对象)来引用
自己新添加的,用this(当前对象)来引用
从父类带过来的也是子类的一部分,所以如果在父类和子类中没有重名的话,都可以用this来引用。
如果有重名的属性或方法,则需要用super和this来区分
**当父类和子类的属性名字一样时,在子类中默认使用的是子类定义的属性,除非明确使用super来调用,所以在子类对象的内存里实际上有2个同名的变量,默认使用的是子类的变量,这种现象称作子类变量隐藏了父类的同名变量。**
**当父类和子类定义的方法名一样时,子类对象内存里只有子类定义的方法,不再有父类定义的方法,这种现象称作子类的方法覆盖了父类的同名方法。**
**访问权限控制符**
private(只能被它所属的类内的其他方法访问);
默认权限(包访问权限);
protected(可以被同一个包内的其他类访问,不同包如果是它的子类的话也可以访问);
public
**对于普通外部类,只有public和默认权限两种,普通外部类不能使用protected和private修饰符**
**类的成员(包括内部类)的访问级别有四种**
**定义在类体内且在方法外的变量称为成员变量**
**定义在方法内的变量称为局部变量**
**类的成员变量有2种:**
一种是类变量,一种是实例变量。
定义成员变量时,若变量前有关键字static,则称为类变量,若没有static关键字,则称为实例变量。
类变量存贮在类的公用区,属于类所有,所有该类的对象共享这一个类变量,而实例变量属于对象所有,每个对象拥有自已独立的实例变量,保存在对象的内存中。
**局部变量也有2种**:
一种是方法的形参,一种是方法体内定义的变量
局部变量的生命周期只存在于方法内,方法调用结束,局部变量也就不存在了。
方法体内的局部变量必须赋初值后才能使用,否则编译器认为该变量没有初始化,不能使用。
**方法声明时,方法名前不加static的是实例方法,加static的是类方法。**
当以类为模板创建多个对象时,则每个对象拥有自己独立的实例方法,但是所有对象共用类的类方法。
类方法属于类所有,第一次加载类时就存在于类的内存了,不用创建对象就可以使用,所以类方法只能使用类变量,因为他们都是在类加载时就存在了。但实例变量不同,实例变量必须在创建了对象后才存在于对象的内存里,所以类方法不能使用实例变量。
实例方法是在对象创建后才存在,有了实例方法后,类变量和实例变量肯定都存在了,所以实例方法可以使用类变量和实例变量。
注意:关键字static需放在方法返回的数据类型的前面
我们前面说过,在类体内、方法外面只能定义成员变量,不能写普通java代码。实际上还有一种情况,可以写static代码块。格式如下:static{ 普通java代码; }
以“static{”开始,到“}”结束,中间可以写普通java代码,这整段代码可以放在定义成员变量的位置,称为static代码块。static代码块的执行是在加载类的时候执行,不需要创建对象。
**final修饰的类变量只能被赋值一次,以后不能改变。要么定义时赋值,要么在类的初始化代码块中赋值,以后不能再赋值。**
[访问修饰符] final 数据类型 变量名[=value];public static final int a=1;
final 数据类型 变量名[=value];final int a=1;
**final修饰的成员方法表示在子类中不能被覆盖。**
[访问修饰符] final 数据类型 方法名([参数列表]){};public final int add(int a,int b){}
**final修饰的类表示在该类不能有子类。**
无继承时的执行顺序总结如下:
(1)类变量和static代码块。
(2)实例变量。
(3)构造方法。
有继承时的执行顺序总结如下:
(1)父类的类变量和static代码块。
(2)子类的类变量和static代码块。
(3)父类的实例变量。
(4)父类的构造方法。
(5)子类的实例变量。
(6)子类的构造方法。
public class FixedAccount extends Account{
private int time;
public void setTime(int time){
this.time=time;
}
public int getTime(){
return time;
}
public FixedAccount(){
this.time=0;
}
public FixedAccount(String number,String name,double yue,int time){
super(number,name,yue);
this.time=time;
}
public void saveMoney(double a){
System.out.println("该账户为定期账户无法存款");
}
public void takeMoney(double a){
Date now =new Date();
int t=int((now.getTime()-this.getbTime.geTime())/1000/3600/24);
if(i<time){
System.out.println("未到期无法取款");
}else{
if(!a==this.getyue){
System.out.println("请一次性全部取出");
}
this.setyue==0;
}
}
public void change(Account other,double a){
System.out.println("定期账户无法取钱");
}
}
public class CreditAccount extends Account{
private double line;
public void setLine(double line){
this.line=line;
}
public int getLine(){
return line;
}
public CreditAccount(){
this.line=0;
}
public CreditAccount(String number,String name,double yue,double line){
super(number,name,yue);
this.line=line;
}
public void saveMoney(double a){
this.getyue()+=a;
}
public void takeMoney(double a){
if((this.getyue()+this.line)<a){
System.out.println("超出额度无法取款");
}
this.setyue(this.getyue()-=a);
}
public void change(Account other,double a){
System.out.println("信用卡账户无法取钱");
}
}
public class Test{
public static void main (String[] args){
FixedAccount count1=new FixedAccount("001","张三",3000,3);
CreditAccount count2=new CreditAccount("002","李四",4000,10000);
count1.takeMoney(200);
....
}
}