Java中的类和对象

1、类和对象

类是创建对象的模板，可以创建多个具有相同属性和行为的对象。
对象是对现实世界事物的模拟，具有属性和行为。

1、访问权限修饰符

①外部类级别
public或不用修饰符
②成员级别
public private protected或不用修饰符

2、类的定义

class ClassName {

}

包括以下内容
⑴访问权限修饰符
⑵类名，是首字母大写的英语名词
⑶类的父类，使用extends关键字，一个类仅能有一个父类
⑷类实现的接口，使用implements关键字，一个类可以实现多个接口，接口名之间使用逗号分隔
⑸类体，使用大括号包围

3、成员变量

声明在类中的变量，使用前必须进行初始化

例如

public class Book {
private String title; // 需要修饰符、变量的类型、变量的名称
private String price;

需要修饰符、变量的类型、变量的名称

4、局部变量

作用范围只在一个语句块

public class Sum {
 public static void main(String[] args) {
  int sum=0;
  for(int i=1;i<10;i++) {
   sum=sum+i;
  }
 }
}

i只能在for循环中使用

5、普通方法

声明有6个部分
典型的方法为

public static void main(String[] args) {

}
/*也有void类型的*/
public void setTitle(String bookTitle) {

}

包含
修饰符 包含权限修饰符、静态修饰符，例如public和static
返回值 没有返回值需要使用void表明
方法名称 使用字母小写的英语名词，例如main
参数列表 放在小括号内，需指明参数类型和名称，如果没有参数，小括号为空
异常列表 使用throws关键字
方法体 放在大括号之间

6、构造方法

构造方法名和所在类的类名一致，没有返回值！！！

主要用于创建对象

构造方法与普通方法的差别：

①不能有返回值
②构造方法的名称与包含该构造方法的类名称完全相同

分为有参和无参构造方法

可以看做构造器

public class Student {
 // 成员变量     
private String name;     
private int age;
 public Student() {
 } //无参构造
 public Student(String name, int age) {      
   this.name = name;       
   this.age = age;     
   }//有参构造

构造方法名称必须与类名完全相同，然后编译器只能通过参数的个数、类型和顺序上的差异来区分不同的构造方法。

7、方法参数的传递

在参数列表中，分为基本类型和引用类型，两个的传递方式都为值传递。
值传递是将参数复制一份，再将复制的内容传递到方法中，与原来的参数无关。
Java 编程语言只有值传递参数。

补：

形参：方法定义时，声明在小括号内的参数

实参：方法调用时，实际传递给形参的值

①参数是基本数据类型

值传递机制为赋值的为变量所保存的数据值

例如

public class V值传递基本数据类型 {
 public static void main(String[] args) {
  V值传递基本数据类型 v=new V值传递基本数据类型(); //创建类的对象来调用方法
  int m=10;
  int n=20;
  System.out.println("进入交换方法前 m: "+m +",n: "+n);
  v.jiaohuan(m, n); //调用交换方法，传递的值是m,n，输出的值肯定为m,n的值
  System.out.println("进入交换方法后 m: "+m +",n: "+n); //该方法被销毁了，还是原来m,n的值
 }
 public void jiaohuan(int a,int b) {  //a,b是形参，由m,n传递给它们值
  int temp = a;
  a=b;
  b=temp;
  System.out.println("a: "+a +",b: "+b);
 }
}

运行结果

前后两次m,n值相同原因是方法被调用后被销毁了

值进入这种方法前后不会发生变化

②参数是引用类型

值传递机制为赋值的为变量所保存的数据的地址值

例如

public class V值传递引用数据类型 {
 public static void main(String[] args) {
  Data data = new Data();
  data.m=10;
  data.n=20;
  System.out.println("进入交换方法前 m: "+data.m +",n: "+data.n);
  V值传递引用数据类型 v = new V值传递引用数据类型();
  v.jiaohuan(data);
  System.out.println("进入交换方法后 m: "+data.m +",n: "+data.n);
 }
 
 //定义一个交换方法
 public void jiaohuan(Data data) {
  int temp = data.m;
  data.m=data.n;
  data.n=temp;
  System.out.println("m: "+data.m +",n: "+data.n);
 }
}

class Data {
 int m;
 int n;
} //使用的是封装

运行结果

这种方法可以改变m,n的值，传递的是地址值

③还有参数个数未知的方法

public class WeizhiMethod {
 private static void print(String... varargs) { //创建参数可变的方法
  for(int i=0;i<varargs.length;i++) {
   System.out.print(varargs[i]+" "); //输出参数的内容
  }
 }
 public static void main(String[] args) {
  print("Java","PHP"); //指定两个参数
  System.out.println(); //换行
  print("Java","PHP","Java"); //指定三个参数
 }
}

运行结果

如果参数与成员变量同名，则能够覆盖该成员变量。如果局部变量与成员变量重名，则能够覆盖该成员变量。如果局部变量与参数重名，则报告错误。

8、匿名对象的使用

创建的对象没有显式的赋给一个变量名，即为匿名对象

new Person().walk; //匿名调用Person对象中的方法
new Person().study; //这两个对象不同

实例

public class Person {
	public void walk() {
		System.out.println("人可以走路");
	}
	public void study() {
		System.out.println("人可以学习");
	}
}

public class PersonTest {
	public void show(Person person) {
		person.walk();
		person.study();
	}
}

public class Test {
	public static void main(String[] args) {
		PersonTest p =new PersonTest(); //创建PersonTest类的对象p
		p.show(new Person()); //通过p调用show方法
		//相当于省略了创建Person类的对象，即：
		/*
		Person person = new Person();
		p.show(person);
		*/
	}
}

9、包装类

1、包装类的定义

基本数据类型	包装类
int	Integer
char	Character
byte	Byte
float	Float
double	Double
boolean	Boolean
short	Short
long	Long

2、基本数据类型、包装类、String类之间的转换

1、基本数据类型转为包装类

public class BaozhuangTest {
	public static void main(String[] args) {
		//基本数据类型->包装类，调用包装类的构造器
		int n1=10;
		Integer in1 = new Integer(n1);
		System.out.println(in1.toString());
		Integer in2 = new Integer("123");
		System.out.println(in2.toString());
		Float f1 = new Float(12.3f);
		System.out.println(f1.toString());
		Boolean b1 = new Boolean(true);
		System.out.println(b1);
		Boolean b2 = new Boolean("True");
		System.out.println(b2);
	}
}

运行结果

2、包装类转为基本数据类型

调用包装类Xxx的xxxValue()方法

public class Bao {
	public static void main(String[] args) {
		Integer in1 = new Integer(10);
		int i1 = in1.intValue();
		System.out.println(i1+6);
	}
}

运行结果

3、基本数据类型、包装类转为String类

调用String重载的valueOf(Xxx xxx)方法

public class ZhuanHuan {
	public static void main(String[] args) {
		int i1 = 10;
		String str1 = i1+"";
		String str11 = String.valueOf(i1);
		float f1 = 12.3f;
		String str2=String.valueOf(f1);
		System.out.println(str1);
		System.out.println(str11);
		System.out.println(str2);
	}
}

运行结果

4、String类转为基本数据类型、包装类

调用包装类的parseXxx(String s)方法

public class StringtoTest {
	public static void main(String[] args) {
		String str1="123";
		int i1 = Integer.parseInt(str1);
		System.out.println(i1);
		String str2 = "true";
		boolean b1 = Boolean.parseBoolean(str2);
		System.out.println(b1);
	}
}

运行结果

10、对象创建和使用

1、对象创建

Test test = new Test();
Test test1 = new Test("a");
//左边声明，右边实例化

2、对象使用

public void call() {
}
t1.call(); //使用一个对象调用类成员方法

使用"."来调用方法和属性

11、this、static、final关键字的用途

1、this

引用成员变量
例如

public a(int a) {
this.a=a; //引用成员变量
}

引用构造方法

public a() {
this(null,null,null,0); //使用this调用一个无参的构造方法
}

2、static

可以直接使用成员变量和成员方法而不创建对象，表示被修饰的成员属于这个类；也可定义静态变量

private static int a; //定义静态变量
public static void a() {
}

static是不允许用来修饰局部变量

3、final

用来修饰类、成员变量和成员方法
①修饰类，该类不能被继承
②修饰成员变量，该变量被赋值后不能修改
③修饰成员方法，该方法不能被子类重写
常见用法是与是static关键字组合来创建常量，例如PI的赋值

public static final PI =3.1415926；

private final int a=2; //声明final修饰的变量

12、包的定义与使用

有默认的包，也可声明包
语法为

package com.mingrisoft;

使用包的优势
①便于区分哪些类是相关的
②在不同的包中，可存在相同名称的类
③使用包来控制访问权限
导入包
⑴使用import语句

import java.util.Date;

这样在文件任何地方都可以使用Date类
导入一个包中的多个类，使用*

import java.util.*;

⑵在使用工具类的地方导入

java.util.Date date = new java.util.Date();

构造方法与普通方法的差别：

①不能有返回值
②构造方法的名称与包含该构造方法的类名称完全相同

作用不同：

构造方法用于创建类的实例并对实例的成员变量进行初始化；成员方法实现对类中成员变量的操作，提供某些功能。

调用方式不同：

构造方法通过new运算符调用，成员方法通过对象调用。

2、注解

1、预定义注解

@Deprecated 用于标示弃用的类或方法，它们不应该再使用
@Override 用于修饰重写的方法，如果没有遵守重写的规则，会给出提示
@SuppressWarnings 用于压制警告信息，例如没有泛型的类型

2、自定义注解

在类的开始部分统一增加注解信息。包括代码的作者、文件创建时间、最后修改时间和版本信息

public @interface Information {
    String author(); //用于保存作者信息
    String date(); //用于保存文件创建时间
    String lastModifyDate(); //用于保存文件最后修改时间
    int version(); //用于保存文件的版本信息
}
@Information(author = "Mingrisoft", date = "2011/2/28", lastModifyDate = "2011/4/2", version = 1)
public class Test {
}

在定义定义注解时，需要使用大括号包含注解的内容。在使用注解时，使用小括号来包含注解的内容。

综合实例 构造方法的应用

//Person类
package com.pcx;
public class Person {
 private String name;
 private String gender;
 private int age;
 public Person() {
  System.out.println("使用无参构造方法创建对象");
 }
 public Person(String name, String gender, int age) { //有参构造方法的格式
  this.name=name; //用this关键字获取值
  this.gender=gender;
  this.age=age;
  System.out.println("使用有参构造方法创建对象");
 }
 public String getName() {
  return name; //返回name
 }
 public String getGender() {
  return gender;
 }
 public int getAge() {
  return age;
 }
}

//PersonTest类
package com.pcx;
public class PersonTest {
 public static void main(String[] args) {
  Person person1 = new Person();
  Person person2 = new Person("小明","男",20);
  System.out.println("员工1的信息");
  System.out.print("姓名："+person1.getName()+" "); //getName()方法获取name的内容
  System.out.print("性别："+person1.getGender()+" ");
  System.out.println("年龄："+person1.getAge()+" ");
  System.out.println("员工2的信息");
  System.out.print("姓名："+person2.getName()+" ");
  System.out.print("性别："+person2.getGender()+" ");
  System.out.print("年龄："+person2.getAge()+" ");
 }
}

运行结果

补例：温度单位转换

package com.pcx;
import java.util.Scanner;
public class Temperature转换 {
 public double toF(double c) { //构造方法
  double f = 1.8*c+32;
  return f;
 }
 public static void main(String[] args) {
  System.out.println("请输入要转换的温度（单位：摄氏度）");
  Scanner sc= new Scanner(System.in);
  double c=sc.nextDouble(); //获得输入的摄氏温度
  sc.close();
  Temperature转换 tc = new Temperature转换(); //创建类的对象
  double f = tc.toF(c);
  System.out.println("转换的温度为："+f);
 }
}

运行结果

最后来个—>总结<—

类和对象

1、设计类就是设计类的成员

类中有属性和方法
属性=成员变量
方法= 类比于C语言中的函数

定义一个Person类

public class Person {

}

有哪些属性：名字、性别、年龄

String name; //可以定义为私有和公共的属性
String gender;
int age;

有哪些方法：学习、行走

public void study() {
   System.out.println("人可以学习");
}
public void walk() {
   System.out.println("人可以行走");
}

故Person类为

public class Person {
 String name; //定义属性姓名
 String gender; //定义属性性别
 int age; //定义属性年龄
 public void study() { 
  System.out.println("人可以学习"); //创建方法
 }
 public void walk() {
  System.out.println("人可以行走"); //创建方法
 }
}

2、类的实例化，创建类的对象

新建一个测试类，PersonTest
①创建类的对象
②通过“对象名.属性”或“对象名.方法”调用类的结构

public class PersonTest {
 public static void main(String[] args) { //不能少了main()方法
 //创建Person类的对象，p1
 Person p1 = new Person();
 
 //调用属性，使用“对象名.属性”
 p1.name="小明";
 p1.gender="男";
 p1.age=18;
 System.out.println(p1.name);
 System.out.println(p1.gender);
 System.out.println(p1.age);
 
 //调用方法，使用“对象名.方法”
 p1.study(); //调用study方法
 p1.speak("中文"); //调用speak方法
    }
}

运行结果