java基础

【练习:】

1.创建程序，在其中定义两个类，Persons类，定义如下:
用setAge() 设置人的合法年龄(0~130),用getAge()返回人的年龄


2.修改上题中类和构造器，增加name属性，使将每次创建Person对象的同时初始化对象的age
属性值和name属性

    'Persons类也是main方法入口类'

public class Persons {


    public static void main(String[] args) {

    //   这样也可以创建p1,构造器的重载
    Persons  p1  = new Persons();

       p1.setAge(12);  //  set方法，封装性的体现

      System.out.println("年龄为:"+p1.getAge());  //  get方法



    Persons  p2  = new Persons(20,"Tom");  //  传入    年龄  姓名


    System.out.printf("name="+p2.getName()+",age="+p2.getAge()); //  输出

    }




      private   int  age;       //私有属性
      private   String  name;   // 私有属性


      //  构造器的重载

     public  Persons(){
          age = 18;   //  默认年龄为18
      }


      //  有参构造器，初始化对象的属性


    public   Persons(int a,String n){   //   年龄    姓名
          age = a;
          name =n;
    }



       //  封装性的体现
      public  void  setAge(int a){    //  设置年龄


         if(a<0 || a>130){
             System.out.println("传入的数据非法!");
         }

                 age =  a;   //   a赋值      给年龄age
      }




       public   int  getAge(){

           return   age;  // 返回年龄

       }



    //  封装性的体现

    public   void   setName (String n){
          name = n;
    }

    public  String  getName(){
          return  name;
    }



}

【结果】

编写两个类，TriAngle和TriAngleTest,其中TriAngle类中声明私有的
底边长 base  和高  height,
同时  声明公共方法访问私有变量，此外，提供类必要的构造器，
另外一个类转中使用这些公共方法，计算三角形面积

【代码】

public class TriAngle {


    private   double  base; //底边长
    private  double  height;  //高

   //计算三角形面积     //  private  只是不能被外部类访问

    public   void  Jisuan (double height,double base){
        double  area = height * base *0.5;
        System.out.println(area);
    }
    
    //  无参构造器
    public   TriAngle(){

    }
    //   有参构造器
    public  TriAngle (double b ,double h){
          base  = b;
          height = h;
    }

    
    //  私有属性的 set  get 方法
    public  void setBase(double b){
         base  = b;
    }

    public   double  getBase(){
         return  base;
    }

    
    //  私有属性的   set  get  方法
  public   void   setHeight (double h){
        height =h;
  }
  
  public    double  getHeight(){
        return  height;
  };
    
}

【测试类】

public class TriAngleTest {


    public static void main(String[] args) {

        TriAngle   t1  = new TriAngle();
         t1.setBase(2.5);
         t1.setHeight(2.5);
        // t1.Base = 2.3;// 私有属性，需要用set    get  方法
       // t1.height = 2.1;// 私有属性，需要用 set方法设置属性值，get方法返回属性值
     System.out.println("base:"+t1.getBase()+",height:"+t1.getHeight());

       //计算三角形的面积
     t1.Jisuan(2.5,2.5);

    }
}

【结果】

javaBean

JavaBean是一种Java类，而且是一种特殊的、可重用的类。
JavaBean必须具有无参数的构造器，所有的属性都是private的，通过提供setter和getter方法来实现对成员属性的访问。

public class Customer {

    //类是public  构造器也是public
    
    private  int  id;
    private  String   name;

    public  Customer(){

    }

    //提供一些方法

    //  set  get  方法
    public  void   setId (int id ){
           this.id=id;
    }

    public  int   getId (){
        return  id;
    }
    
    //  set   get  方法
    public  void  setName  (String name){
        this.name = name;
    }
    public  String  getName  (){
      return   name;
    }
    
}

【this用法】   Person类

class  Person  {

    private   String  name;
    private   int  age;


    //  构造器
    public   Person(){

        //this();  //自己调用自己   "只能别人调用默认的"

       //  构造器中也可以写方法，调用比如  eat()方法
//        this.eat();  //调用我们当前正在创建的eat 方法

    String   info   =  "Person 初始化时，需要考虑如下的 1 ,2 3,4  ...(共40 行代码)";
              System.out.println(info);

    }
    //  不避开与类中的属性同名

    public    Person (String name){
            // 构造器里面调用构造器
       this(); //  调用默认构造器

        //   name  = name;  //这样不行
        this.name =name;     //  属性      形参

        // Person 初始化时，需要考虑如下的 1 ,2 3,4  ...(共40 行代码)

    }


    public   Person  (int age)
    {
        this();      //调用 默认构造器
        this.age = age;
        // Person 初始化时，需要考虑如下的 1 ,2 3,4  ...(共40 行代码)

    }

    //  也可以加个  两个参数 构造器   构成重载


    public  Person  (String name , int age){

        this(age) ;   //   age放进来 调用     public    Person  (int age)

        this.name = name;  //当前正在创建的对象的属性
       // this.age =age;

        // Person 初始化时，需要考虑如下的 1 ,2 3,4  ...(共40 行代码)

    }



    //  提供 get set  方法
    public   void   setName (String name){
       this.name   = name;
    //   System.out.println(this);  //当前对象   注意这里不能写p1.name    newd的对象可以是p1  (这里指得是当前对象)

    }


    public  String  getName()
    {
          return name;

    }

    public  void  setAge (int a)
    {
        age  =a;

    }

    public  int  getAge ()
    {
          return    age;

    }

    public   void  eat() {
        System.out.println("人吃饭");
           this.study();      //方法里面调用方法   省略this.
                //谁调用eat方法，我就调用他的study方法
    }

    public  void  study()
    {
        System.out.println("人学习");

    }


}

【测试类】

public class PersonTest {

    public static void main(String[] args) {

        Person   p1  = new Person();

         p1.setAge(20);

         p1.setName("张三");

         p1.eat();
      //   p1.study();

         System.out.println(p1.getAge());
         System.out.println(p1.getName());

         System.out.println();
       Person   p2  = new Person("jerry",20);
    System.out.println(p2.getAge());


        System.out.println();
    Person  p3   = new Person("TOM");



    }

}

 【结果】

【小结】  主要理解 构造器中的this  不能自己调用自己，不能互相调用，可以套娃，代码首行

 

 

3.this  调用构造器
   1.我们在类的构造器中可以显示的使用 "this(形参列表)"方式，来调用本类中指定的其他构造器
   2.构造器中不能通过  “this(形参列表)”方式调用自己
    3.一个类中有n个构造器，那么最多有n-1构造器中使用了 "this(形参列表)"方式
    4.规定 :    "this(形参列表)"必须声明在当前构造器的首行
    5.构造器内部，最多只能声明一个 "this(形参列表)"，用来调用其他的构造器

【稀疏数组练习】

分析问题:     因为该二维数组的很多值都是默认0，因此记录了很多没有意义的数据

  解决: 稀疏数组

  当以个数组大部分元素为0，或者为同一只值的数组时，可以使用稀疏数组来保存改数组
  稀疏数组 处理方法        记录数组一共有几行几列       多少个不同的值    不同值的元素和行列及值记录在一个规模小的数组中。

public class XishuArray {
         //  代码实现
        // 创建一个二维数组，  11* 11    0没有棋子    1：黑棋    2:白琪
         public static void main(String[] args) {

             int [][]   arr  = new int[11][11];
             arr[1][2]=1;    //黑棋
             arr[2][3]=2;    //白棋
             arr[5][6]=2 ;   //白棋

             System.out.println("原数组为:");

             for(int[] x: arr){
                 for(int i: x){
                      System.out.printf("%d\t",i);   //
                 }
                 System.out.println();

             }

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

             //  转化为稀疏数组
               int  sum =0;
             //  先获取有效个数的值:
             for (int i=0;i<11;i++){
                 for(int j =0;j<11;j++){
                     if(arr[i][j]!=0){
                         sum ++;
                     }
                 }
             }

             System.out.println("稀疏数组的有效个数值:"+sum);

             //  根据有效数值转化为稀疏数组


             int[][]  b= new  int [sum+1][3];  //  这里不应该是1吗

            b[0][0] = 11;      // 行
             b[0][1] = 11;     // 列
             b[0][2] = sum;    // 值

             //遍历二维数组，将非0的值存放到稀疏数组中



             /* ********这里是重点************/

             int count =0;  //用于记录，是第几个非0数据
             for (int i=0;i<11;i++){
                 for(int j =0;j<11;j++){
                     if(arr[i][j]!=0){
                         count++;
                         b[count][0]=i;   //  [0][0] =i   行
                         b[count][1]=j;     //  [1][1]  =j  列
                         b[count][2]=arr[i][j];  // (这个值本身)[2][2]=arr  [0][0] [0][j]
                     }
                 }
             }


             //  输出稀疏数组的形式

          System.out.println();
          System.out.println("得到稀疏数组为~~~~~");

            for(int i =0;i<b.length;i++){
                   //这里换行符号得注意
                                 //  第一列  第二列  第三列  换行  所在行的第一个数据(第一列)  第二  第三
                System.out.printf("%d\t%d\t%d\t\n",b[i][0],b[i][1],b[i][2]);
            }                  //  [0][0]   [0][1]   [0][2]
                              //   [1][0]    [1][1]   [1][2]
                               //  [2][0]     [2][1]   [2][2]

       System.out.println();
            
            //将稀疏数组 -- >  恢复成原始的二维数组

             /*++
             1.读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的b

              2.在读取稀疏数组后面的几行的数据，并赋给 原始的二维数组  即可

              */
             
         }
}

继续更新