Java自学003(类和对象)

项目、包、类命名规范

1. 项目名全部小写
2. 包名全部小写
3. 类名首字母大写，如果类名由多个单词组成，每个单词的首字母都要大写。
   如：public class MyFirstClass{}
4. 变量名、方法名首字母小写，如果名称由多个单词组成，每个单词的首字母都要大写。
   如：

int index=0;
       public void toString(){}

5.常量名全部大写
如：public static final String GAME_COLOR=”RED”;

所有命名规则必须遵循以下规则：
列表内容
1)、名称只能由字母、数字、下划线、$符号组成
2)、不能以数字开头
3)、名称不能使用JAVA中的关键字。
4)、坚决不允许出现中文及拼音命名

面向对象 （class类.package包）

面向对象三种属性
1.封装性
不用关心class的内部构造 ，封装起来便于调用
2.继承性
Java中一个类只可以继承一个类
想成一棵树，树干，树枝，树叶…
所有树枝叫一个类，所有树叶叫一个类，树枝这个类是树叶这个类的父类
3.多态性
树干，树枝，树叶（树叶类中包括树叶形状，树叶颜色，树叶大小….这就是多态）
例子
设置初始时间为13点整，用24时制和12时制显示，并且显示此时间在13小时27分6秒和99小时89分99秒后时间分别是多少。

package time1;

import java.lang.Object;

public class Time1 extends Object {
    private int hour;
    private int minute;
    private int second;
    public Time1(){
        setTime(13,0,0);
    }
    public void setTime(int h,int m ,int s){
        hour=((h>=0&&h<=24)?h:0);
        minute=((m>=0&&m<=60)?m:0);
        second=((s>=0&&s<=60)?s:0);
    }//设置时间的取值范围
    public String toUniversalString(){
        return hour+":"+minute+":"+second;
    }//24时制显示方法
    public String toStandarString(){
        return ((hour==12||hour==0)?12:hour%12)+":"+minute+":"+second+":"+(hour<12?"AM":"PM");
    }
}//12时制显示方法

package time1;
import javax.swing.JOptionPane;

public class TimeTest1 {
    public static void main(String[]args){
        Time1 time1=new Time1();
        String output="time1对象建立后\n24小时制格式时间："+
        time1.toUniversalString()+"\n12小时制格式时间："+
        time1.toStandarString();
        time1.setTime(13, 27, 6);
        output +="\n用setTime方法修改time1对象后\n24时制格式时间"
                + time1.toUniversalString()+"\n12小时制格式时间："+
                time1.toStandarString();
        Time1 time2=new Time1();
        time2.setTime(99, 89, 99);
        output +="\n用setTime方法修改time2对象后\n24时制格式时间"
                + time1.toUniversalString()+"\n12小时制格式时间："+
                time1.toStandarString();
        JOptionPane.showMessageDialog(null, output, "时钟类测试建立了两个对象", JOptionPane.INFORMATION_MESSAGE);
        System.exit(0); //添加退出
    }
}

显示结果：

二.类的声明
①定义类

[修饰符] class <类名> [extends 父类名] [implements 接口列表]{
} 

import java.util.*;//List在java.util.包装中
public class Frist implements List{

 }

---

public class Frist extends A{ //继承A这个父类
         String name = "水果";//定义属性（成员变量和局部变量等）
            public void getstr(){//定义方法，方法返回值为空，可以用new调用这个方法，确切应该是用“new”建立了一个存储空间，并给这给空间取名和赋值
                  name = "SB水果";}
            public void getstr(){//定义方法2，方法返回值为空，
                  name = "SB";
                 }
}

---

修饰符、解释和其访问权限等

修饰符	权限	解释
public	公共类	该类可以被它所在包之外的其他类访问和引用
abstract	抽象类	抽象类一定是拿来继承的，只做声明，不做实现的方法，不能用new关键字创建对象，不能被实例化，且不能用private和static关键字进行修饰
final	final类	不能被继承，没有子类，提高程序安全性用final类（编译器和解析器）

解释补充：
abstract     在类声明中使用abstract修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。abstract 类不能直接用new运算符创建对象！必须产生其子类，由子类创建对象，才可以调用abstract 类的方法。一个类只能使用一次继承关系，但可以通过实现多个接口（interface）实现多重继承

http://blog.youkuaiyun.com/escaflone/article/details/10418651

abstract例子：

执行程序LetMeDoIt类

package mypackage;

public class LetMeDoIt {
    public static void main(String[]args){
         MyAbstractClass EA =new ExtendsA();//复制在MyAbstractClass类子类中的对象到an，对象不在 MyAbstractClass类中
         EA.fangfa01();
         MyAbstractClass EB =new ExtendsB();
         EB.fangfa01();
    }

}

创建的抽象类

package mypackage;

public abstract class MyAbstractClass {//定义抽象类（为什么前面是public abstract？和直接是abstract以及用abstract public都一样？）
    public abstract void fangfa01();//定义了一个抽象的方法。
}

继承于抽象类的一个类，叫ExtendsA

package mypackage;

public class ExtendsA extends MyAbstractClass{
    public void fangfa01(){//继承了MyAbstractClass的fangfa01()方法，具体实现在这儿输入
        System.out.println("ExtendsA继承MyAbstractClass类输出方法的具体实现在这儿！");
    }

}

继承于抽象类的另个类，叫ExtendsB

package mypackage;

public class ExtendsB extends MyAbstractClass{
    public void fangfa01(){//继承了MyAbstractClass的fangfa01()方法，具体实现在这儿输入
        System.out.println("ExtendsB继承MyAbstractClass类输出方法的具体实现在这儿！");
    }

}

执行结果：
ExtendsA继承MyAbstractClass类输出方法的具体实现在这儿！
ExtendsB继承MyAbstractClass类输出方法的具体实现在这儿！

---

final 是不能被继承的类！

final class xxx{
}

成员变量和局部变量

[修饰符][static][final] [translent][volatile]<变量类型><变量名>

构造方法的概念及用途

• 构造方法没有返回值
• 构造方法的名称要与本类的名称相同

public class AnyThing {
        public AnyThing(){              //定义无参构造方法
            this("this 调用有参构造方法"); //使用this调用有参构造方法
            System.out.println("无参构造方法"); 
        }
        public  AnyThing(String name){  //定义有参结构方法
            System.out.println("有参构造方法");
        }
}

创建对象

Fruit fruit;
fruit=new Fruit();

Fruit fruit=new Fruit();

使用对象

package java6_2_5;

public class Circ {
    //声明变量
    final float Pl=3.14159f;
    public float r=0.0f;
    //计算面积方法
    public float getArea(){
        float area=Pl*r*r;
        return area;
    }
    //计算周长方法
    public float getZouchang(){
        float Zouchang=2*Pl*r;
        return Zouchang;
    }
    //定义主方法测试程序
    public static void main(String[]args){
        Circ circ=new Circ();
        circ.r=40f;
        //float r=40;主方法要用才用，不用省略掉
        float area=circ.getArea();
        System.out.println("圆面积为："+area);
        float Zouchang=circ.getZouchang();
        System.out.println("圆周长为："+Zouchang);
    }
}

包

创建包：“包1.包2.包3.…….包n”，包1最外层

import

import com.wgh.Cire; //包中的某个类
import com.wgh.*;    //多个类

JAVA 中的继承关系

继承使用

[修饰符]class子类名 extends 父类名

例子：

父类

public class Animal{
    public boolean live=true;
    public String skin=" ";
    public void eat(){
        System.out.println("动物需要吃食物");
    }
    public void move(){
        System.out.println("动物会运动");
         }
}

子类

public class Bird extends Animal{
    public String skin="羽毛";
    public void move(){
        System.out.println("鸟会飞翔");
        }
    }

执行

public class Zoo{
    public static void main(String[]args){
        Bird bird=new Bird();
        bird.eat();
        bird.move();
        System.out.println("鸟有："+bird.skin);
    }
}

子类move和父类方法move重名，父类方法被子类覆盖了

使用this关键字

this.成员变量名
this.成员方法名()
栗子：

public class Frist{
    String color="绿色";
    public void harvest(){
        String color="红色";
        System.out.println("颜色为："+color);
        System.out.println("成员变量："+this.color);
        }
        public static void main(String[]args){
            First first=new frist();
            first.harvest();
            }
    }

运行结果：
颜色为：红色
成员变量：绿色

使用super关键字

super.成员变量名
super.成员方法名([参数列表])