一：习题讲解

1:撰写程序，在一个源文件中写两个类，一个类是Student,有一个显示信息的方法show；

另一个类是Main,包含有入口方法，在入口方法中调用另一个类(Student)。

 思考：源文件名叫什么？

              如果一个源文件中包含很多类，如果有一个类中有main方法（入口方法）

        那么源文件名 就是这个类名

 package test;

publicclass Main {

    //类是模版，对象是模版下的一个例子

    publicstaticvoid main(String[] args) {

       //首先要产生类的一个对象，也就是说产生一个学生对象

       Student stu=new Student();

       //对象是具体的。也就是说对象的属性要赋值的

       stu.name="张三";

       stu.sex="男";

       stu.age=20;

      

       stu.show();

    }

}

class Student{

     String name;

     String sex;

     intage;

    //作用就是显示信息

    publicvoid show(){

       System.out.println("姓名="+name+",性别="+sex+",年龄="+age);

    }

}

这个例子还有很多可以改进的地方

A：希望在stu.show();这条语句上面，把鼠标放上去能够出现中文注释。起到说明注释作用

     推广，在任何方法上，通过把鼠标放上去能够出现中文注释。起到说明注释作用。

    怎么做？在要显示的方法上面打上/** 回车

    /**

     *显示信息

     */

    publicvoid show(){

       System.out.println("姓名="+name+",性别="+sex+",年龄="+age);

    }

       /**

     *得到姓名

     *@return字符串

     */

    public String getName(){

       returnname;

    }

 总结，java的注释有3种   //    /**/ /**

B：显示信息的方法，java 最好采用一个固定的方法 toString 不要使用什么show，print等其他方法,虽然说其他方法没有错

       toStirng 是固定写法

/**

     *用来显示信息

     */

    public String toString() {

       // TODO Auto-generated method stub

       return"姓名="+name+",性别="+sex+",年龄="+age;//return 后面就是格式化信息

    }  

 toString 这种方法 怎么调用呢？

           Student stu=new Student();

       //对象是具体的。也就是说对象的属性要赋值的

       stu.name="张三";

       stu.sex="男";

       stu.age=20;

      

       //stu.show();

       System.out.println(stu);//输出学生信息会自动调用toString

C:改进第3个

    Student类的属性 name,sex,age 我们希望不能够随便被别的类修改，要进行限制

    stu.name="张三";

    stu.sex="男";

    stu.age=20;

 为什么限制，如果能够被随便修改的话，会导致name,sex,age 不符合现实要求.

 比如 sex=“ssss”，age=“-100”；

 那么怎么做，才能够限制呢？就是面向对象的3大特征之一：封装！

2：有一个账户，账户中有存款余额，您可以对账户进行存款与提款的动作，

并可以查询以取得存款余额。使用面向对象的方式分析，

说明其中的类，对象并列举他的属性和方法。

面向对象的分析，怎么分析

账户

静态特征：余额

动态特征：存款，提款，查询

package test;

publicclass Account{

    floatye=10f;

    /**

     *存钱

     *@paramc存多少钱

     */

    publicvoid cunkuan(float c){

       ye=ye+c;

    }

    /**

     *取钱

     *@paramc取多少钱

     *@return得到多少钱

     */

    publicfloat qukuan(float c){

       if(c>=ye){

        System.out.println("余额不足");

        return 0;

       }else{

        ye=ye-c;

        return c;

       }

    }

    public String toString(){

       return"余额为="+ye;

    }

}

package test;

publicclass Test {

    /**

     *@paramargs

     */

    publicstaticvoid main(String[] args) {

       // TODO Auto-generated method stub

       /*

        *从第1句代码到最后一句，都是面向对象的

        *a.cunkuan(100f);只告诉做什么事，具体怎么做交给了cunkuan的方法了

        */

       Account a=new Account();

       a.cunkuan(100f);

       System.out.println(a);

      

       a.qukuan(1000f);

       System.out.println(a);

      

       a.qukuan(10f);

       System.out.println(a);

    }

}

变量的作用域！

面向对象有3大特征：封装，继承，多态

1：为什么需要封装

       对于

    stu.name="张三";

    stu.sex="男";

    stu.age=20;

 这3行代码，可以推广，对于任何类的属性，都是需要赋值。赋值是不是有含义

 比如age 可以赋值为有含义，也可以赋值为-100 这种没有含义的值。

 所以我们希望 能够对属性赋值的时候，进行限制。！！！

 这就是为什么需要封装的原因

2：封装是什么意思 就是隐藏细节。目的是 不能直接看到，或者访问到

为什么需要封装 做个例子

package test2;

publicclass YgTeacher1 {

    public String name;

    //String name 前面写public

    //意味着这个name赋值可以在任意类下的YgTeacher1类的对象赋值

    publicintage;

   

    /**

     *返回自我介绍的内容

     */

    public String introduction() {

    return "大家好！我是" + name + "，我今年"+ age+"岁";

    }

}

package test2;

publicclass YgTeacher1Test {

    publicstaticvoid main(String[] args) {

       YgTeacher1 teacher = new YgTeacher1();

       teacher.name = "李芳";

       teacher.age = -10;

       System.out.println(teacher.introduction());

    }

}

对于teacher对象 我们赋值为李芳与-10,这样才语法角度是没有问题，因为能够出正确结果

但是从现实角度，是不符合现实 所以我们要改进，要限制属性的赋值！！！

那么怎么给属性赋值有含义，我们通过封装去解决

3：怎样才能够给属性封装

       A:属性私有化 也就是说在属性前面加上private 关键字 private 私有的

private 含义就是只能在这个类中访问（赋值与取值） 在别的类中是不能直接赋值的！teacher.name = "李芳";

       teacher.age = -10; 会报错

       B：提供公有方法访问私有属性

          公有方法 就是在方法前面加上public

       我们这种公有方法的作用就是 对私有属性进行赋值 与取值。所以把这类

              公有方法叫做 setters方法和getters方法

              package test2;

//类应该来说改进后的代码

publicclass YgTeacher2 {

    //第一步在所有属性前加私有关键字 private

    private String name;

    privateintage;

   

    //第二步设置所有私有属性的set 和get方法

    //set方法就是以set开头的方法，就是就是赋值

    //get方法就是以get开头的方法，就是返回值取值

    //可以采用快捷方式

    //source -->generate getters and setters方法

    public String getName() {

       returnname;

    }

    publicvoid setName(String name) {

       //this 是个关键字

       //this 表示哪个对象调用方法，那么this就是哪个对象

       //this 可以区别属性与参数的

       this.name = name;

    }

    publicint getAge() {

       returnage;

    }

    publicvoid setAge(int age) {//可以通过if 来限制属性赋值必须有含义

       this.age = age;

       if(age<22){

           System.out.println("赋值太小");

           this.age=22;

       }

}

    public String toString() {

       // TODO Auto-generated method stub

       return"name="+name+",age="+age;

    }

       

       

}

package test2;

publicclass YgTeacher2Test {

    publicstaticvoid main(String[] args) {

       // TODO Auto-generated method stub

       YgTeacher2 gjy=new YgTeacher2();

       gjy.setName("gjy");

       gjy.setAge(23);

       System.out.println(gjy);

      

       YgTeacher2 w=new YgTeacher2();

       w.setName("w");

       w.setAge(19);

      

       System.out.println(w);

    }

}

4：给属性赋值，难道只有一个封装吗？没有别的方法吗？

 肯定不止，还有构造方法也可以给属性赋值！！！

封装通过set方法给属性赋值

创建对象时，通过构造方法给属性赋值

构造方法的语法：

       名字与类名一样，还有没有返回类型

package test2;

publicclass YgTeacher3 {

    private String name;

    privateintage;

    public String getName() {

       returnname;

    }

    publicvoid setName(String name) {

       this.name = name;

    }

    publicint getAge() {

       returnage;

    }

    publicvoid setAge(int age) {

       this.age = age;

    }

   

    //没有参数的构造方法

    //构造方法的作用就是给属性赋值

    //构造方法什么时候调用：在创建对象的时候调用

    public YgTeacher3(){

       this.name="yg1";

       this.age=22;

    }

   

   

    public String toString() {

       returnname+","+age;

    }

}

package test2;

publicclass YgTeacher3Test {

    publicstaticvoid main(String[] args) {

       // TODO Auto-generated method stub

       //new YgTeacher3();这句代码执行，会自动调用没有参数的构造方法

       //因为YgTeacher3()括号中没有参数

       YgTeacher3 yg=new YgTeacher3();

       System.out.println(yg);

    }

}

构造方法的分类

       构造方法可以分2类 1是没有参数的构造方法

                                          2是有参数的构造方法

   这2类构造方法可以写在一个类中

package test2;

publicclass YgTeacher3 {

    private String name;

    privateintage;

    public String getName() {

       returnname;

    }

    publicvoid setName(String name) {

       this.name = name;

    }

    publicint getAge() {

       returnage;

    }

    publicvoid setAge(int age) {

       this.age = age;

    }

   

    //没有参数的构造方法

    //构造方法的作用就是给属性赋值

    //构造方法什么时候调用：在创建对象的时候调用

    public YgTeacher3(){

       this.name="yg1";

       this.age=22;

    }

    public YgTeacher3(String name,int age){

       this.name=name;

       this.age=age;

    }

   

    public String toString() {

       returnname+","+age;

    }

}

package test2;

publicclass YgTeacher3Test {

    publicstaticvoid main(String[] args) {

       // TODO Auto-generated method stub

       //new YgTeacher3();这句代码执行，会自动调用没有参数的构造方法

       //因为YgTeacher3()括号中没有参数

       YgTeacher3 yg=new YgTeacher3();

       System.out.println(yg);

      

       YgTeacher3 yg2=new YgTeacher3("yg",34);

       System.out.println(yg2);

    }

}

方法的分类

       1：实例方法 或叫成员方法 （除了构造方法外的都是实例方法）

              实例方法就是类产生实例（对象）后调用的方法，有几个对象，那么就可以调用实例方法

           实例方法的语法呢，

       2：构造方法

       3：静态方法

              语法：在方法中有static 这个关键字！就是静态方法 static 就是静态

              最典型的static 方法

              public static void main(String []args){

              }

              作用：从内存上说，静态方法和静态变量都是属于类的。无论产生多少个对象

                      静态方法和静态变量都只有一个。

package test;

publicclass Test {

    staticinti=1;//在变量前面加一个static 就是静态变量

    intj=1;//一般的变量也叫实例变量

    publicstaticvoid main(String[] args) {//静态方法

    //静态方法中只能放静态方法和静态变量和实例变量

       Test t=new Test();//当运行new Test()的时候

                  //要自动分配内存，i 静态变量会分配内存，并且只分配一次

                  //无论后面产生多少个对象，静态变量只分配一次

                  //j 实例变量也会分配内存但是是产生一个对象就分配一次内存

       t.i++;//2

       //静态变量和方法的调用可以是t.i 对象名.静态方法或变量

       //也可以类名.静态变量或方法

       t.j++;// 2

      

       Test t2=new Test();

       t2.i++;//3

       t2.j++; //2

      

       System.out.println("i="+t.i);//t.i 和t2.i 都是3 也就是说i是属于类的

                                //跟对象无关

       System.out.println("j="+t.j);

      

       System.out.println("i="+t2.i);

       System.out.println("j="+t2.j);

    }

}

为什么要使用封装？！

       因为我们要对属性赋值要进行限制。使属性值要有含义

属性赋值 ：有2种方式

       第一个就是封装

              A：给属性私有化

              B：产生setters和getters方法

       第二个就是构造方法

              一般在类中提供几个构造方法，可以根据不同的要求，调用不同参数的构造方法

方法重载！！！

       什么是方法重载

        有几个方法（无论是实例方法还是构造方法），它们的方法名一样，但是参数的类型或个数不一样。跟修饰符与返回类型无关。并且这几个方法在一个类中。这就是方法重载

       生活中有很多方法重载的例子

              比如说 吃 吃这个方法，我们可以随便定义2个

                     Public void eat(){

                            Syso(“吃饭”);

                     }

                  Public int eat(String type){

                            If(type==”筷子”){

                            }

                            If(type=”叉子”){

                            }

                     }

Java 语言 本身提供了很多方法重载的例子

       package test;

publicclass Test {

    publicstaticvoid main(String[] args) {

       double d=10.0;

       //println 就是典型的方法重载

       System.out.println("s");

       System.out.println(d);

      

       System.out.println(Math.abs(-10));//求-10的绝对值

       System.out.println(Math.random());//求0-1之间的随机数，是double类型

      

      

       //Math 这是一个数学类，是java本身提供的。在java.lang这个包下

       //Math.abs 这是类名.方法名这是方法必须是静态方法下才能够使用

      

    }

}

构造方法也可以重载

       public YgTeacher3(){

       this.name="yg1";

       this.age=22;

    }

    public YgTeacher3(String name,int age){

       this.name=name;

       this.age=age;

    }