主题：课件8下载——Java的类之一

类是Java的核心和本质内容，也是Java语言面向对象的基础。

1、简介
从简单的方面理解，类是一种数据类型，能够封装相关变量和函数，并能控制外界对其的访问权限，同时还能把一些业务逻辑封装进来，使得对类的使用相对变得简单。利用类定义的变量通常称为对象变量。

1、1 封装变量的类
public class Exec
{
        public int i=0;
        public int j=0;
}

使用该类的程序为：
public class Main
{
        public static void main(String args[])
        {
                Exec c=new Exec();
                c.i=1;
                System.out.println(c.i);
        }
}

说明：
1）类中的变量通常称为属性（Attribute、Property）
2）public表示外界可以自由访问该属性成员，如改成private，则不可以，如
public class Exec
{
        private int i=0;
        private int j=0;
}

使用该类的程序为：
public class Main
{
        public static void main(String args[])
        {
                Exec c=new Exec();
                c.i=1;
                System.out.println(c.i);
        }
}
编译报错为：i has private access in Exec

1、2 封装函数的类
public class Exec
{
        private int i=0;
        private int j=0;
        
        public void func()
        {
                System.out.println("Hello!");
        }
}

使用该类的程序为：
public class Main
{
        public static void main(String args[])
        {
                Exec c=new Exec();
                c.func();
        }
}

说明：
1）类中的函数通常称为方法（Method）
2）public和private同样可以修饰方法
3）通常，类中的属性都不应该设置为public，而是private较好，此时通过public方法来间接访问，如
学生类：
public class Stu
{
        public String name;
        public double height;
}
使用该类的程序为：
public class Main
{
        public static void main(String args[])
        {
                Stu s=new Stu();
                s.name="Tom";
                s.height=1.70;
                System.out.println(s.name);
                System.out.println(s.height);
        }
}

虽然上述程序正常，但是存在一些问题，如用户可以输入一些语法合格但是逻辑并不正确的值给Stu类中的属性，如s.height=170，同时输出界面上也显得过于简单，甚至连身高的单位都没有指明。如果使用下述写法，将会解决此类问题：
学生类：
public class Stu
{
        private String name;
        private double height;
        
        public void setName(String n)
        {
                if(n.equals(""))
                        name="null";
                else
                        name=n;
        }
        
        public String getName()
        {
                return "Name is "+name;
        }
        
        public void setHeight(double h)
        {
                if(h<0 || h>3)
                        height=0;
                else
                        height=h;
        }
        
        public String getHeight()
        {
                return String.valueOf(height)+"M";
        }
}
使用该类的程序为：
public class Main
{
        public static void main(String args[])
        {
                Stu s=new Stu();
                
                s.setName("Tom");
                s.setHeight(1.70);
                
                System.out.println(s.getName());
                System.out.println(s.getHeight());
                
                s.setName("");
                s.setHeight(170);
                
                System.out.println(s.getName());
                System.out.println(s.getHeight());
        }
}
输出为：
Name is Tom
1.7M
Name is null
0.0M

说明：
1）这些用来设置和读取属性的函数方法通常为一对，如果属性名称为xxx，则方法名称习惯为setXxx()和getXxx()。它们不仅是此时用户访问属性的唯一途径，而且可以封装一些业务逻辑，所以对类的访问将更加不易于出错。
2）这些方法也可以不全部出现，如只有getXxx()方法的属性将会成为只读属性。
3）这种属性和访问属性的方法分开定义的好处在于用户只有通过这些方法才能访问属性，所以用户的界面程序中并不需要考虑访问属性时的一些逻辑，同时在类中也无需考虑将来用户如何使用，只要类的这些接口定义一致，完全可以在不修改用户程序的情况下，通过修改被调用类（当然只是修改类方法的实现，而非类的方法名称等，这些展示出来的类方法称之为接口定义）而改变用户的功能。如：
直接将
public String getHeight()
{
        return String.valueOf(height)+"M";
}
改为：
public String getHeight()
{
        return String.valueOf(height*100)+"CM";
}
用户程序的输出就为
Name is Tom
170.0CM
Name is null
0.0CM

1、3 构造函数
这是类中一种特殊的函数方法，会在类生成变量的时候自动被调用，所以通常用于初始化。

上述的学生类可以考虑使用构造函数进行属性的设置，如
public class Stu
{
        private String name;
        private double height;
        
        public Stu(String n,double h)
        {
                setName(n);
                setHeight(h);
        }
        
        public void setName(String n)
        {
                if(n.equals(""))
                        name="null";
                else
                        name=n;
        }
        
        public String getName()
        {
                return "Name is "+name;
        }
        
        public void setHeight(double h)
        {
                if(h<0 || h>3)
                        height=0;
                else
                        height=h;
        }
        
        public String getHeight()
        {
                return String.valueOf(height)+"M";
        }
}
使用该类的程序为：
public class Main
{
        public static void main(String args[])
        {
                Stu s=new Stu("Tom",1.70);
                
                System.out.println(s.getName());
                System.out.println(s.getHeight());
        }
}

说明：
1）构造函数的定义方法是固定的，名称始终和类名一样（大小写也一样），返回类型为空，但是不用写void（写了反而不对）。参数的类型自己按照调用时的要求来定义。里面的代码也可以自己定义，如果功能已经和其他方法重复，可以考虑通过调用类中的其他方法来实现。
2）构造函数可以重载，否则会产生其他问题，如上述的学生类不变，使用该类的程序为：
public class Main
{
        public static void main(String args[])
        {
                Stu s=new Stu();
                
                s.setName("Tom");
                s.setHeight(1.80);
                
                System.out.println(s.getName());
                System.out.println(s.getHeight());
        }
}
编译报错为：
cannot resolve symbol
symbol  : constructor Stu ()

所以，通过引入重载的构造函数可以满足有参和无参的多种调用情况，新的学生类为：
public class Stu
{
        private String name;
        private double height;
        
        public Stu()
        {
        }
        
        public Stu(String n,double h)
        {
                setName(n);
                setHeight(h);
        }
        
        public void setName(String n)
        {
                if(n.equals(""))
                        name="null";
                else
                        name=n;
        }
        
        public String getName()
        {
                return "Name is "+name;
        }
        
        public void setHeight(double h)
        {
                if(h<0 || h>3)
                        height=0;
                else
                        height=h;
        }
        
        public String getHeight()
        {
                return String.valueOf(height)+"M";
        }
}

1、4 toString()方法
利用这个方法可以实现直接输出某个类对象的相关信息，如：
public class Main
{
        public static void main(String args[])
        {
                Stu s1=new Stu();
                Stu s2=new Stu();
                
                System.out.println(s1);
                System.out.println(s2);
        }
}
输出为：
Stu@126b249
Stu@182f0db

说明：
此时直接调用类对象输出，会自动调用toString()方法，也就是说，上述程序等价于：
public class Main
{
        public static void main(String args[])
        {
                Stu s1=new Stu();
                Stu s2=new Stu();
                
                System.out.println(s1.toString());
                System.out.println(s2.toString());
        }
}
而toString()方法虽然没有直接在学生类中定义，但是系统会自动添加（通过默认的继承），它的默认行为就是打印上述信息，这个信息就是：类名@对象ID号，由于s1和s2所引用的对象不是一个对象，所以ID号并不一样。
通过改写此方法，可以改变其默认行为：
public class Main
{
        public static void main(String args[])
        {
                Stu s1=new Stu("Tom",1.70);
                Stu s2=new Stu("Alice",1.60);
                
                System.out.println(s1);
                System.out.println(s2);
        }
}