详解Java类与对象

1.类的定义：
类是对象的抽象，它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称为属性，成员方法用于描述对象的行为，可简称为方法。

class Person{
int age;       //定义int类型的变量age
 //定义speak（）方法
 void speak(){
 System.out.println("大家好，我今年"+age+"岁！");
 }
}

此程序就定义了一个类，其中，Person是类名，age是成员变量，speak(）是成员方法。在成员方法speak（）中可以直接访问成员变量age。

class Person{
  int age=10;       //类中定义的变量被称作成员变量
  void speak(){     //方法内部定义的变量被称作局部变量
   int age=60;
   System.out.println("大家好，我今年"+age+"岁！")
}
}

2.对象的创建与使用
使用new关键字来创建对象： 类名 对象名称=new 类名（）；
创建Person类的实例对象代码如下：

Person p=new Person();

如何访问对象的成员？

class Test{
public static void main(String args[]){
Person p1=new Person;    //创建第一个Person对象
Person p2=new Person;    //创建第二个Person对象
p1.age=18;               //为age属性赋值
p1.speak();              //调用对象的方法
p2.speak();
}
}

3.类的设计与封装

public class Student{
 String name;
 in age;
 public void introduce(){
//方法中打印属性name和age的值
System.out.println("大家好，我叫"+name+",我今年"+age+"岁！");
}
}

所谓类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在它所在类中被访问。为了能让外界访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获得属性值的getXxx（）方法和设置属性值的setXxx（）方法。

class Student{
private String name;    //将name属性私有化
private int age;        //将age属性私有化
//下面是公有的getXxx()和setXxx()方法
public String getName(){
reture name;
}
public void setName(String stuName){
name=stuName;
} 
public int getAge(){
return age;
}
public void setAge(int stuAge){
//下面是对传入的参数进行检查
if(stuAge<=0){
System.out.println("年龄不合法……");
}else{
age=stuAge;       //对属性赋值
}
}
public void introduce(){
System.out.printin("大家好，我叫"+name+",我今年"+age+"岁！");
}
}
public class Test{
public static void main(String[] args){
Student stu=new Student();
stu.setAge(-30);
stu.setName("李芳");
stu.introduce();
}
}

3.构造方法
A.构造方法的定义
在一个类中定义的方法如果满足以下三个条件，该方法称为构造方法。如下：
a.方法名与类名相同。
b.在方法名的前面没有返回值类型的声明。
c.在方法中不能使用return语句返回一个值。

class Person{
int age;
//定义有参的构造方法
Public Person(int a){
age=a;              //为age属性赋值
}
public void speak (){
System.out.println("I am"+age+"years old.!");
}
}
public class Test{
public static void main(String[] args){
Person p=new Person(20);
p.speak();
}
}

B.构造方法的重载
与普通方法一样，构造方法也可以重载，在一个类中可以定义多个构造方法，只要
每个构造方法的参数类型或参数个数不同即可。

class Person{
String name;
int age;
//定义两个参数的构造方法
public Person(String con_name,int con_age){
name=con_name;         //为name属性赋值
age=con_age;           //为age属性赋值
}
//定义一个参数的构造方法
public Person（String con_name){
name=con_name;         //为name属性赋值
}
public void speak{
//打印name和age的值
System.out.println("大家好，我叫"+name+",我今年"+age+"岁！");
}
}
public class Test{
public static void main(String[] args){
//分别创建两个对象p1和p2

Person p1=new Person("陈杰");
Person p2=new Person("李芳",18);
//通过对象p1和p2调用speak（）方法
p1.speak();
p2.speak();
}
}

4.this关键字
a.通过this关键字可以明确地去访问一个类的成员变量，解决与局部变量名称冲突问题。

class Person{
int age;
public Person(int age){
this.age=age;
}
public int getAge(){
return this.age;
}
}

b.通过this关键字调用成员方法

class Person{
public void openMouth(){

}
public void speak(){
 this.openMonth();
 }
}

c.构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用“this（[参数1，参数2…]）”的形式来调用其他的构造方法。

class Person{
public Person(){
System.out.println("无参的构造方法被调用……");
}
}
public class Test{
 public static void main(String[] args){
Person p=new Person("itcast");    //实例化Person对象
}
}

在使用this调用类的构造方法时，应注意以下几点。
a.只能在构造方法中使用this调用其他的构造方法，不能在成员方法中使用。
b.在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。
c.不能在一个类的两个构造方法中使用this互相调用。
5.static关键字
a.静态变量
在一个Java类中，可以使用static关键字来修饰成员变量，该变量被称为静态变量。
静态变量被所有实例共享，可以使用“类名.变量名”的形式来访问。

class Student{
  static String schoolName;      //定义静态变量schoolName
}
public class Test{
public static void mian(String[] args){
Student stu1=new Student();      //创建学生对象
Student stu2=new Student();    
Student.schoolName="图论"        //为静态变量赋值
System.out.println("我的学校是"+stu1.schoolName); //打印第一个学生对象的学校
System.out.println("我的学校是"+stu2.schoolName);//打印第二个学生对象的学校
}
}

b.静态方法
当需要实现在不创建对象的情况下就可以调用某个方法，也就是使该方法不必和对象绑在一起，只需要在类中定义的方法前加static关键字即可，这种方法叫做静态方法。静态方法可以使用“类名.方法名”的方式来访问，也可以通过类的实例对象来访问。

class Person{
public static void sayHello(){     //定义静态方法
}
}
class Test{
public static void main(String[] args){
Person.sayHello();                 //调用静态方法
}
}

静态代码块
在Java类中，使用一对大括号包围起来的若干行代码被称为一个代码块，用static关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块只执行一次。

class Test{
//静态代码块
static{
System.out.println("静态类的测试代码块执行了");
}
public static void main(String[] args){
//下面的代码创建了两个Person对象
Person p1=new Person();
Person p2=new Person();
}
}
class Person{
static String country;
//下面是一个静态代 
static{
country="china";
System.out.println("Person类中的静态代码块执行了");
}
}