java学习1 -基础练习笔记

java学习1 -基础练习笔记

>  java语言基础

a=9
b=12 a=10
c=13 a=11
//switch-case
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("成绩为差!");
   }
 }
}
//while
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);
  }
}
//用while循环语句求1到10000的既能被2整除又能被3整除的数的和
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);
 }
}
//do-while
//模拟ATM插卡输入密码的过程。
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(登陆成功);
  }
}
//for
//输出九九乘法表
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);
       }
    }
  }
}
//continue
//输出1-100之间的所有不能被3整除的数字
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++;
    }
  }
}
//return
//计算长方形的面积
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;//开户时间
  //每个属性都要get和set方法--成员方法
  public  void  setNumber(String nb){ //set方法只用void不要static；另外参数要加上类型
    this.number=nb;
  }
  public  String  getNumber(){  //get方法只用类型，返回值直接写变量
    return number;
  }
  public  void  setName(String n){ 
    this.name=n;
  }
  public  String  getName(){  //get方法只用类型，返回值直接写变量
    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(){  //get方法只用类型，返回值直接写变量
    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;
  }
  //调用类的功能性方法！！！不加staic 
  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）子类的构造方法。
    
//编写银行账户Account的子类定期账户类和信用卡账户类
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);
    ....
  }
}