1. 类
类主要包含3个部分：
- 类属性：用来描述类本身所抽象出的事物的属性
- 类方法：用来描述这个被抽象出的事物可以做什么
- 构造方法：每个类都至少会有一个特殊的方法，该方法提供了创建类对象的初始化机制
类的定义：
【修饰符】 class 类名 【extends 父类名】 【implements 接口名】
{
类成员变量的声明；
类方法声明；
}
.java源文件结构：
Java程序的源文件是一个以“.java”结尾的文件，同时该文件中只能有一个类被声明为public类，若存在被声明为public的类时，类的名字必须与“.java”源文件名相同。
在一个源文件中，可以包含三种顶层元素：package（包声明）、import（类库导入语句）、class（类声明）。如果同时出现，必须按照package、import、class的顺序出现。
main()入口方法：
public static void main(String argv[])
{}
main()方法中的字符串数组arvg[]是用来从命令行接收用户参数的。
采用命令行执行Java程序的语句由四个部分组成：命令名，命令参数（是可选的），应用程序的名称（即源文件中的主类类名），用户输入的参数（多个参数之间用空格分隔）
访问修饰符public、private、protect、default
- public：可以跨类访问，而且可以跨包访问
- private：访问权限限制最窄的修饰符。只能被该类的对象访问，其子类不能访问，更不允许跨包访问
- proctet：能被类本身的方法及子类方法访问，即使子类在不同的包中也可以访问
- default：只允许在同一个包中进行访问
构造方法：
构造方法的名字和类的名字是相同的，并且没有任何类型的返回值，在构造方法前，只可以使用访问修饰符public，private及protected。
如果一个类中没有定义类的构造方法，系统会自动为这个类创建一个缺省的默认构造器，该构造器参数及方法均为空。
参数的传递：
传递的参数共有如下两种：
- 基本类型参数所传递的都是基本数据类型，包括数值型、布尔型等。在这种情况下所有的参数传递都采用值传递的方式。也就是说，当传递一个参数到方法中时，方法获得的只是该参数值的一个拷贝。因此，方法不会改变参数变量的值，只会使用该变量的值。
-
public class Example1 { public static void add(int a, int b) { int c=a+b; System.out.println("c="+c); a=c; } public static void main(String[] args) { int a=10; int b=20; add(a,b); System.out.println("a="+a); } }c=30
a=10
-
- 对象引用型参数，方法中获得的是该对象的内存地址，因此方法可以改变该对象中的属性，但是不能改变对象本身。
-
public class Example2 { public static void change(String str, char ch[]) { str="Changed"; ch[0]=‘C‘; } public static void main(String[] args) { String s=new String("World"); char ch[]={‘H‘,‘e‘,‘l‘,‘l‘,‘o‘}; change(s,ch); System.out.println(s+ " and "+ String.valueOf(ch)); } }World and Cello
成员方法重载与过载：
- 方法重载：是面向对象语言的特性，只存在于父类和子类之间。当父类中的一个方法在继承它的子类中重新获得定义时，若该方法的方法名、参数、返回值类型均不变，只有方法体发生了变化时，就称子类的方法重载了父类的方法。
- 方法过载，是编程语言均有的特性，与面向对象无关，存在于同一个类中。指的是多个方法拥有同一个名字，每个方法都有一套唯一的、不同于其他同名方法的参数列表。
-
public class Example { int a=10; int b=20; int c=30; public Example() { System.out.println("a+b="+add(a,b)); System.out.println("a+b+c="+add(a,b,c)); } public int add(int x, int y) { return x+y; } public int add(int x, int y, int z) { return x+y+z; } public static void main(String[] args) { new Example(); } }a+b=30
a+b+c=60
static静态成员：
static关键字可以用来修饰成员变量、方法以及代码模块。使用static修饰过的变量、方法都称之为静态成员。静态成员附属于类本身，而不附属于类的成员变量。
需要注意的是，静态方法中不能直接访问非静态的成员变量。
public class StaticExample1 {
static int num=10;
public static void main(String[] args) {
System.out.println(StaticExample1.num);
}
}
public class StaticExample2 {
public static void showString()
{
System.out.println("This is a static method.");
}
public static void main(String[] args) {
//不创建类的情况下，直接调用类中的静态方法
StaticExample2.showString();
}
}
final关键字：
final关键字可以用于类、方法、变量前，用来表示该关键字所修饰的类、方法、变量具有不可变的特性。
- final关键字用于基本数据类型变量前，这时表面该关键字修饰的变量是一个常量，在定义后，该变量的值就不能再被改变，同时在定义时必须被初始化
- final关键字用于方法声明前，被final修饰的方法被称为最终方法，该方法只能被调用，不能被重载，但是可以被过载
- final关键字用于类名前，final关键字修饰的类被称为最终类，该类不能被其他类继承
public class FinalExample {
static final double pie=3.14;
public static void circularityArea(String r)
{
double radius=Double.valueOf(r).doubleValue();
System.out.println("The circularity‘s area is: "+ pie*radius*radius);
}
public static void circularityPerimeter(String r)
{
double radius=Double.valueOf(r).doubleValue();
System.out.println("The circularity‘s area is: "+ pie*radius*2);
}
public static void main(String[] args) {
if(args.length!=1)
{
System.out.println("Error!");
System.exit(0);
}
System.out.println("The circularity‘s radius is: "+args[0]);
circularityArea(args[0]);
circularityPerimeter(args[0]);
}
}
判断对象所属类：
- 获取对象所属类的名字：String name = 对象名.getClass().getName();
- 使用instanceof运算符的语法格式： boolean bool = 对象名 instanceof 类名；
实战练习：
简单模拟一个商店客户折扣卡的功能，自定义Customer类用来保存某个商店中的客户的折扣卡信息。在主类CustomerDemo中，创建Customer类的一个数组对象，该数据对象中包含了3个Customer对象，用来保存3个不同的消费者各自持有的折扣卡信息。通过这3个对象，可以根据用户消费的金额来改变用户在本店中所能享受的折扣价格。
public class CustomerDemo {
Customer customer[] = new Customer[3];
public CustomerDemo()
{
customer[0]=new Customer("c001", "wangxyw","BeiJing","[email protected]");
customer[1]=new Customer("c002", "Xu Quan", "ShangHai", "[email protected],com");
customer[2]=new Customer("c003", "Xu Guang Yang", "BeiJing", "[email protected]");
customer[0].buy(2800.00);
customer[0].setDiscount();
customer[1].buy(1688.00);
customer[1].setDiscount();
customer[2].buy(980.00);
customer[2].setDiscount();
for(int i=0; i<customer.length;i++)
{
System.out.println("customer[" + i + "]");
System.out.println("CardID: "+customer[i].getCardID());
System.out.println("name: "+ customer[i].getName());
System.out.println("cost: "+ customer[i].getCost());
System.out.println("discount: "+ customer[i].getDiscount()*10);
System.out.println("address:" + customer[i].getAddress());
System.out.println("email:" + customer[i].getEmail()+ "\n");
}
}
public static void main(String[] args) {
new CustomerDemo();
}
}
class Customer{
private String cardID;
private String name;
private double cost=0;
private String address;
private String email;
private double discount = 1;
public Customer(String id, String name, String add, String email)
{
cardID=id;
this.name=name;
address=add;
this.email=email;
}
//用于购买商品后，增加用户消费值
public void buy(double cost)
{
this.cost+=cost;
}
//根据用户的消费额度来改变用户所能享受的折扣
public void setDiscount()
{
if(cost>2000.00)
discount-=0.1;
else if(cost>1000.00)
discount-=0.05;
}
//用于获取和设置用户地址的方法
public String getAddress()
{
return address;
}
public void setAddress(String address)
{
this.address=address;
}
//用于获取和设置用户卡号的方法
public String getCardID()
{
return cardID;
}
public void setCardID(String cardID)
{
this.cardID=cardID;
}
//用于获取用户消费金额的方法
public double getCost()
{
return cost;
}
//用于获取用户的折扣值得方法
public double getDiscount()
{
return discount;
}
//用于获取和设置用户信箱地址的方法
public String getEmail()
{
return email;
}
public void setEmail(String email)
{
this.email=email;
}
//用于获取和设置用户名的方法
public String getName()
{
return name;
}
public void setName(String name)
{
this.name=name;
}
}
customer[0]
CardID: c001
name: wangxyw
cost: 2800.0
discount: 9.0
address:BeiJing
email:[email protected]
customer[1]
CardID: c002
name: Xu Quan
cost: 1688.0
discount: 9.5
address:ShangHai
email:[email protected],com
customer[2]
CardID: c003
name: Xu Guang Yang
cost: 980.0
discount: 10.0
address:BeiJing
email:[email protected]