目录

第一章：类与对象

一、类与对象的概念

1、定义类

2、创建对象

 3、构造方法

二、封装机制

1、封装的概念

2、类的严谨定义

3、类修饰符 

三、数据成员

1、用static修饰的静态数据成员

2、静态数据成员的初始化

3、用final修饰最终数据成员

四、成员方法 —— 类似于函数

1、声明成员方法的格式

2、形参和实参 

3、用static修饰的静态方法 

4、用final修饰的最终方法 

---

第一章：类与对象

一、类与对象的概念

1、定义类

class Dog //class指出这是个类 Dog是类标识
{
    //类的属性(静态特征)
    String name;
    int weight;
    int height;
    
    //类的方法(动态特征)
    public void move()
    {……}
    public void showdog()
    {……}
}

2、创建对象

1、声明引用变量

格式

class_name object1,object2; //类名 + 引用变量名表

Dog d1,d2;

声明引用变量时，系统只为该变量分配引用空间，存放在java定义的栈内存中，其值为null，此时并未创建具体的对象

2、创建对象 

声明了一个引用变量，就可以将它与一个创建的对象相关联。

构造方法的方法名=类名

创建对象

引用变量名 = new 构造方法();

d1=new Dog();

声明引用变量的同时创建对象

类名 引用变量名=new 构造方法()

Dog d1=new Dog();

new可以为对象分配存储空间，并存放在java定义的堆内存中，引用变量的值是该对象存储的地点

3、使用对象

package text;

import java.util.Scanner;

class Dog
{
	public String name;
	public int w;
	public int h;
	
	public void show()
	{
		System.out.println("Name:"+name);
		System.out.println("Weight:"+w);
		System.out.println("Height:"+h);
	}
}

public class Text //主类 
{
    public static void main(String[] args)
    {
        Dog d1=new Dog();
        d1.name="hh";
        d1.w=20;
        d1.h=10;
        d1.show();

        Dog d2;
        d2=new Dog();
    }
}

 3、构造方法

1. 构造方法的方法名 = 类名
2. 能够简化对象数据成员的初始化操作
3. 不能对构造方法指定类型，它有隐含的返回值，该值由系统内部使用
4. 构造方法一般不能被显式直接调用，在创建一个类的对象的同时，系统会自动调用该类的构造方法将新对象初始化
5. 如果没有在自定义类里定义该类的构造方法，系统将为这个类定义一个空构造方法

package text;

import java.util.Scanner;

class Dog
{
	public String name;
	public int w;
	public int h;
	
	//构造方法——简化初始化操作
	public Dog(String cname,int cw,int ch)
	{
		name=cname;
		w=cw;
		h=ch;
	}
	
	public void show()
	{
		System.out.println("Name:"+name);
		System.out.println("Weight:"+w);
		System.out.println("Height:"+h);
	}
}

public class Text 
{
    public static void main(String[] args)
    {
        Dog d1=new Dog("xiaobai",20,50);
        d1.show();
        
        Dog d2;
        d2=new Dog("kaka",10,30);
        d2.show();
    }
}

//也可以用this
	public Dog(String name,int w,int h)
	{
		this.name=name;
		this.w=w;
		this.h=h;
	}

二、封装机制

1、封装的概念

java提供4种访问控制：

公共（public） 保护（protected） 包（package） 私有（private）

2、类的严谨定义

[类修饰符] class 类名 [extends 父类名][implement 接口列表]
{
    数据成员；
    成员方法；
} 

3、类修饰符 

 ①无修饰符

• 无修饰符的类只能被同一个包（package）里的类使用
• 无修饰符的类可以被同一个程序文件中的类使用，但不能被其他程序文件的类使用

class c1  //无修饰符的类c1
{
    int a=45;
}

public class C4_4 //公共类
{
    public static void main(String[] args)
    {
        c1 x=new c1(); //在C4_4类里创建了一个无修饰符类c1的对象
        System.out.println(c1.a);
    }
}

②public修饰符

• public不但可供它所在的包内其他类使用，也可以供其他包里的类使用
• 在程序里可以用import引用其他包的public类
• java规定，在一个程序文件中，只能定义一个public类，其余类可以是无修饰的类，也可以是final类

③final修饰符

• 将一个类定义为final类，则能将它的内容、属性和功能固定，与其类名形成稳定的映射关系，保证引用该类所实现的功能都是准确无误的
• final不能被任何其他类所继承，即不能再派生子类，截断了病毒传入途径

final class P1
{
}

public class C4_4 extends P1 //错误 final类不能有继承类

④abstract修饰符

        称为抽象类

⑤类修饰符的注意事项

• 可以同时用两个修饰符来修饰一个类，修饰符的顺序无影响
• 没有 final abstract 这种组合

三、数据成员

1、用static修饰的静态数据成员

用static修饰的数据成员是不属于任何一个类的具体对象，而是属于类的静态数据成员的

• 它被保存在类的内存区的公共存储单元中，因此一个类的任何对象访问它，存取到的都是相同的数值
• 可以通过类名加点操作符访问它
• static类数据成员仍属于类的作用域，可以用public static、private static修饰

class c1
{
    static double x=8;
}

public class C4_4
{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        c1 m=new c1();
        c1 n=new c1();
        m.x=0.1;
        System.out.println("m="+m.x);
        System.out.println("n="+n.x);
        System.out.println("c1="+c1.x);
    }
}

输出结果

m=0.1
n=0.1
c1=0.1

2、静态数据成员的初始化

静态初始化器

• 静态初始化器用于对类的静态数据成员的初始化，而构造方法用来对新创建的对象进行初始化
• 静态初始化器不是方法

package text;

import java.util.Scanner;

public class Text
{
	public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        cc m=new cc(); //m=50
        cc m1=new cc(); //m1=49
        cc m2=new cc(); //m2=48
        System.out.println("m2="+m2.show);
        System.out.println("m1="+m1.show);
        System.out.println("m="+m.show);
    }
}

class cc
{
	static int n,m; //占用公共区域
	int show;
	static //静态初始化器
	{
		n=20;
		m=50;
	}
	cc()
	{
		show=m--;
	}
}

输出结果

m2=48
m1=49
m=50

3、用final修饰最终数据成员

• 用final修饰的数据成员是标识符常量
• 若某个数据成员是常量，最好将此常量声明为static final，可以节省空间

package text;

import java.util.Scanner;

public class Text
{
	public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        cc m=new cc(); //m.nn=20
        cc m1=new cc(); //m1.nn=21
        cc m2=new cc(); //m2.nn=22
        //m1.nn=99; 错误 因为nn是标识符常量
        System.out.println("m2.nn="+m2.nn);
        System.out.println("m1.nn="+m1.nn);
        System.out.println("m.nn="+m.nn);
        System.out.println("m.k="+m.k);
    }
}

class cc
{
	static int n=20;
	final int nn;//标识符常量
	final int k=40;
	cc()
	{
		nn=n++;
	}
}

 

四、成员方法 —— 类似于函数

1、声明成员方法的格式

[修饰符]返回值的类型 成员方法名(形参表) throw[异常表]

java的方法和c++中的函数类似

• 方法体内的变量是局部变量，只能在本方法内有效
• 在方法体内定义变量时，变量前不能加修饰符
• 局部变量在使用前必须先赋值

2、形参和实参 

实参可以值传递给形参，形参不能传值给实参

3、用static修饰的静态方法 

• 静态方法可直接用类名来调用方法
• static修饰的方法是静态方法，它是属于整个类的类方法
• 不用static修饰的方法，是属于某个具体类的对象的方法
• static方法只能访问static数据成员，不能访问非static数据成员，但非static方法可以访问static数据成员
• static方法只能访问static方法，不能访问非static方法，但非static方法可以访问static方法

4、用final修饰的最终方法