首页 > 代码库 > Java基础-类
Java基础-类
Java基础第八天
类的初始化过程
Student s = new Student();在内存中做了哪些事情?
加载Student.class文件进内存
在栈内存为s开辟空间
在堆内存为学生对象开辟空间
对学生对象的成员变量进行默认初始化
对学生对象的成员变量进行显示初始化
通过构造方法对学生对象的成员变量赋值
学生对象初始化完毕，把对象地址赋值给s变量
面向对象练习
定义一个类Demo,其中定义一个求两个数据和的方法，定义一个测试了Test，进行测试。
/*
定义一个类Demo,其中定义一个求两个数据和的方法，
定义一个测试了Test，进行测试。
变量什么时候定义为成员变量：
如果这个变量是用来描述这个类的信息的，那么，该变量就应该定义为成员变量。
变量到底定义在哪里好呢?
变量的范围是越小越好。因为能及时的被回收。
*/
//方式1
/*
class Demo {
public int sum() {
int a = 10;
int b = 20;
int c = a + b;
return c;
}
}
*/
//方式1满足了我们的要求，但是不好。
//因为参与操作的数据现在是固定的。
//方式2
/*
class Demo {
public int sum(int a,int b) {
return a + b;
}
}
*/
//方式2可以满足我们的要求，但是呢我们学习过来面向对象的思想。
//我就再想，a，b可不可以定义为成员变量呢?
/方式2可以满足我们的要求，但是呢我们学习过来面向对象的思想。
//我就再想，a，b可不可以定义为成员变量呢?
//如果可以，我们再改进一版
class Demo {
int a;
int b;
public int sum() {
return a + b;
}
}
//虽然这种方式可以，并且好像是符合了面向对象的思想。
//但是不好。
//因为我们曾经说过：类是一组相关的属性和行为的集合。
//并且类是通过事物转换过来的
//而类中的成员变量就是事物的属性
//属性是用来描述事物的
//同理：成员变量其实是用来描述类的。
//测试类
class Test {
public static void main(String[] args) {
//创建对象
//方式1测试
/*
Demo d = new Demo();
System.out.println(d.sum());
*/
//方式2测试
/*
Demo d = new Demo();
int a = 10;
int b = 20;
System.out.println(d.sum(a,b));
*/
//方式3测试
Demo d = new Demo();
d.a = 10;
d.b = 20;
System.out.println(d.sum());
}
}
定义一个长方形类,定义 求周长和面积的方法，然后定义一个测试了Test2，进行测试。
/*
定义一个长方形类,定义 求周长和面积的方法，
然后定义一个测试了Test2，进行测试。
长方形的类：
成员变量：
长，宽
成员方法：
求周长：(长+宽)*2;
求面积：长*宽
注意：
import必须出现在所有的class前面。
*/
import java.util.Scanner;
class ChangFangXing
{
//长
private int length;
//宽
private int width;
//设置长
public void setLength(int length){
this.length = length;
}
//获取长
public int getLength(){
return length;
}
//设置宽
public void setWidth(int width){
this.width = width;
}
//获取宽
public int getWidth(){
return width;
}
//周长
public int getZhouChang(){
return (length + width)*2;
}
//面积
public int getArea(){
return length * width;
}
}
class Test2
{
public static void main(String[] args)
{
ChangFangXing cfx = new ChangFangXing();
Scanner scanner = new Scanner(System.in);
System.out.println("请输入长");
int length = scanner.nextInt();
System.out.println("请输入宽");
int width = scanner.nextInt();
cfx.setLength(length);
cfx.setWidth(width);
int zhouchang = cfx.getZhouChang();
System.out.println("周长=" + zhouchang);
int area = cfx.getArea();
System.out.println("面积=" + area);
}
}定义一个员工类,自己分析出几个成员，然后给出成员变量，构造方法，getXxx()/setXxx()方法，以及一个显示所有成员信息的方法。并测试。
/*
需求：
定义一个员工类,自己分析出几个成员，
然后给出成员变量，构造方法，getXxx()/setXxx()方法，
以及一个显示所有成员信息的方法。并测试。
分析：
员工
成员变量：
员工编号，姓名，年龄
构造方法：
无参构造方法
成员方法：
getXxx()/setXxx()
show();
*/
class Employee
{
//员工ID
private String employeeId;
//员工姓名
private String name;
//员工年龄
private int age;
/**
构造方法
*/
public Employee(){
}
public Employee(String employeeId,String name,int age){
this.employeeId = employeeId;
this.name = name;
this.age = age;
}
//设置员工ID
public void setEmployeeId(String employeeId){
this.employeeId = employeeId;
}
//获取员工ID
public String getEmployeeId(){
return employeeId;
}
//设置员工姓名
public void setName(String name){
this.name = name;
}
//获取员工姓名
public String getName(){
return name;
}
//设置员工年龄
public void setAge(int age){
this.age = age;
}
//获取员工年龄
public int getAge(){
return age;
}
//成员方法
public void show(){
System.out.println("员工编号： "+employeeId+"\t员工姓名： "+name+"\t员工年龄： "+age);
}
}
class EmployeeTest
{
public static void main(String[] args)
{
Employee employee = new Employee();
employee.setEmployeeId("CX8093283");
System.out.println(employee.getEmployeeId());
employee.setName("张三");
System.out.println(employee.getName());
employee.setAge(28);
System.out.println(employee.getAge());
Employee employee1 = new Employee("CX8397314","李四",32);
employee1.show();
}
}定义一个类MyMath,提供基本的加减乘除功能，然后进行测试。
/**
定义一个类MyMath,提供基本的加减乘除功能，然后进行测试。
*/
import java.util.Scanner;
class MyMath
{
//加法
public int sum(int a,int b){
return a+b;
}
//减法
public int subtraction(int a,int b){
return a-b;
}
//乘法
public int multiplication(int a,int b){
return a*b;
}
//除法
public int division(int a,int b){
return a/b;
}
}
class MyMathDemo
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数：");
int a = sc.nextInt();
System.out.println("请输入第二个数：");
int b = sc.nextInt();
MyMath myMath = new MyMath();
int sum = myMath.sum(a,b);
System.out.println("加法结果为："+sum);
int subtraction = myMath.subtraction(a,b);
System.out.println("减法结果为："+subtraction);
int multiplication = myMath.multiplication(a,b);
System.out.println("乘法结果为："+multiplication);
int division = myMath.division(a,b);
System.out.println("除法结果为："+division);
}
}static关键字
可以修饰成员变量和成员方法
static关键字特点
随着类的加载而加载
优先于对象存在
被类的所有对象共享
这也是我们判断是否使用静态关键字的条件
可以通过类名调用
static关键字注意事项
在静态方法中是没有this关键字的
静态方法只能访问静态的成员变量和静态的成员方法
/*
定义一个人类
姓名和年龄都是变化的，这个我能接收，因为每个人的姓名和年龄是不同的。
但是，我们现在选取的几个人都是中国人，他们的国籍是一样的。
一样的国籍，我每次创建对象，在堆内存都要开辟这样的空间，
我就觉得有点浪费了。怎么办呢?
针对多个对象有共同的这样的成员变量值的时候，
Java就提高了一个关键字来修饰：static。
*/
class Person
{
private String name;
private int age;
private static String country;
public Person(){
}
public Person(String name,int age,String country){
this.name = name;
this.age = age;
this.country = country;
}
public void show(){
System.out.println("姓名："+name+"\n年龄："+age+"\n国籍："+country);
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
public void setCountry(String country){
this.country = country;
}
public String getCountry(){
return country;
}
}
class PersonDemo
{
public static void main(String[] args)
{
Person person1 = new Person();
person1.setName("林青霞");
person1.setAge(19);
person1.setCountry("中国");
person1.show();
Person person2 = new Person();
person1.setName("杨幂");
person1.setAge(32);
person1.show();
System.out.println("Hello World!");
}
}案例二代码：
/*
static的特点：(它可以修饰成员变量，还可以修饰成员方法)
A:随着类的加载而加载
回想main方法。
B:优先于对象存在
C:被类的所有对象共享
举例：咱们班级的学生应该共用同一个班级编号。
其实这个特点也是在告诉我们什么时候使用静态?
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
举例：
饮水机(用静态修饰)
水杯(不能用静态修饰)
D:可以通过类名调用
其实它本身也可以通过对象名调用。
推荐使用类名调用。
静态修饰的内容一般我们称其为：与类相关的，类成员
*/
Static内存图
static关键字注意事项
/*
【面试】static关键字注意事项
A:在静态方法中是没有this关键字的
如何理解呢?
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在。
B:静态方法只能访问静态的成员变量和静态的成员方法
静态方法：
成员变量：只能访问静态变量
成员方法：只能访问静态成员方法
非静态方法：
成员变量：可以是静态的，也可以是非静态的
成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
简单记：
静态只能访问静态。
*/
【面试】静态变量和成员变量的区别
所属不同
静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
main方法是静态的
public static void main(String[] args) {}
public 被jvm调用，访问权限足够大。
static 被jvm调用，不用创建对象，直接类名访问
void被jvm调用，不需要给jvm返回值
main 一个通用的名称，虽然不是关键字，但是被jvm识别
String[] args 以前用于接收键盘录入的
演示案例：
/*
main方法的格式讲解：
public static void main(String[] args) {...}
public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。
main:是一个常见的方法入口。我见过的语言都是以main作为入口。
String[] args:这是一个字符串数组。值去哪里了?
这个东西到底有什么用啊?怎么给值啊?
这个东西早期是为了接收键盘录入的数据的。
格式是：
java MainDemo hello world java
*/
class MainDemo {
public static void main(String[] args) {
//接收数据后
System.out.println(args);
System.out.println(args.length);
//System.out.println(args[0]);
for(int x=0; x<args.length; x++) {
System.out.println(args[x]);
}
}制作帮助文档
制作工具类
ArrayTools
制作帮助文档(API)
javadoc -d 目录 -author -version ArrayTool.java
/*
我想要对数组进行操作
在同一个文件夹下，类定义在两个文件中和定义在一个文件中其实一样的。
*/
class ArrayDemo {
public static void main(String[] args) {
//定义数组
int[] arr = {28,55,37,46,19};
//需求：遍历数组
/*
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]);
}else {
System.out.print(arr[x]+", ");
}
}
*/
//如果我有多个数组都要进行遍历，那么，代码的重复度就很高
//如何改进呢?用方法改进
//调用
//静态方法
//printArray(arr);
//非静态方法
//ArrayDemo ad = new ArrayDemo();
//ad.printArray(arr);
//测试类的作用：创建其他类的对象，调用其他类的功能。
//而我们现在的操作是跟数组相关的，所以，你应该把这些操作定义到数组操作类中
//定义一个数组的操作类
//有了数组操作类之后的调用
//ArrayTool at = new ArrayTool();
//at.printArray(arr);
//方法改进为静态后，就可以直接通过类名调用
ArrayTool.printArray(arr);
}
/*
public static void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]);
}else {
System.out.print(arr[x]+", ");
}
}
}
*/
//假设该方法不是静态的
/*
public void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]);
}else {
System.out.print(arr[x]+", ");
}
}
}
*/
}
class ArrayTool {
//把构造方法私有，外界就不能在创建对象了
private ArrayTool(){}
public static void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]);
}else {
System.out.print(arr[x]+", ");
}
}
}
}
版本二
http://www.cnblogs.com/hnrainll/archive/2011/10/11/2206804.html API文档
/**
* 这是针对数组进行操作的工具类
* @author xxx
* @version V.1
*/
public class ArrayTool {
//把构造方法私有，外界就不能在创建对象了
/**
* 这是私有构造
*/
private ArrayTool(){}
/**
* 这是遍历数组的方法，遍历后的格式是：[元素1, 元素2, 元素3, ...]
* @param arr 这是要被遍历的数组
*/
public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]+"]");
}else {
System.out.print(arr[x]+", ");
}
}
}
/**
* 这是获取数组中最大值的方法
* @param arr 这是要获取最大值的数组
* @return 返回数组中的最大值
*/
public static int getMax(int[] arr) {
int max = arr[0];
for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
}
}
return max;
}
/**
* 获取指定元素在数组中第一次出现的索引，如果元素不存在，就返回-1
* @param arr 被查找的数组
* @param value 要查找的元素
* @return 返回元素在数组中的索引，如果不存在，返回-1
*/
public static int getIndex(int[] arr,int value) {
int index = -1;
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
index = x;
break;
}
}
return index;
}
}
/*
我想要对数组进行操作
如何制作一个说明书呢?
A:写一个工具类
B:对这个类加入文档注释
怎么加呢?
加些什么东西呢?
C:用工具解析文档注释
javadoc工具
D:格式
javadoc -d 目录 -author -version ArrayTool.java
目录：就可以写一个文件夹的路径
制作帮助文档出错：
找不到可以文档化的公共或受保护的类：告诉我们类的权限不够
*/
class ArrayDemo
{
public static void main(String[] args){
int[] arr = {31,43,14,65,57,34,56,89};
//遍历数组
ArrayUtilTool.printArr(arr);
//获取数组中最大值
System.out.println(ArrayUtilTool.getMax(arr));
//获取指定元素在数组中第一次出现的索引，如果元素不存在，就返回-1
System.out.println(ArrayUtilTool.getIndex(arr,65));
}
}API制作过程
javadoc -d 目录 -author -version ArrayTool.java
如何使用文档
1:打开帮助文档
2:点击显示，找到索引，看到输入框
3:知道你要找谁?以Scanner举例
4:在输入框里面输入Scanner，然后回车
5:看包
java.lang包下的类不需要导入，其他的全部需要导入。
要导入：
java.util.Scanner
6:再简单的看看类的解释和说明，别忘了看看该类的版本
7:看类的结构
成员变量字段摘要
构造方法构造方法摘要
成员方法 方法摘要
8:学习构造方法
A:有构造方法就创建对象
B:没有构造方法成员可能都是静态的
9:看成员方法
A:左边
是否静态：如果静态，可以通过类名调用
返回值类型：人家返回什么，你就用什么接收。
B:右边
看方法名：方法名称不要写错
参数列表：人家要什么，你就给什么；人家要几个，你就给几个
通过API学习Math类
Math类概述
Math包含用于执行基本数学运算的方法
Math类特点
没有构造方法，因为成员都是静态的
Math类讲解一个方法
获取随机数
获取1-100之间的随机数
案例：
/*
Math:类包含用于执行基本数学运算的方法
由于Math类在java.lang包下，所以不需要导包。
特点：
没有构造方法，因为它的成员全部是静态的。
掌握一个方法：
获取随机数
public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
*/
class MyMath
{
public static void main(String[] args)
{
for(int i = 0;i < 13;i++){
int rd = (int)(1+Math.random()*13);
System.out.println(rd);
}
}
}案例：
猜数字小游戏
/*
猜数字小游戏(数据在1-100之间)
分析：
A:程序产生一个随机数。(被猜的)
B:键盘录入数据。(你猜的)
C:把你猜的和被猜的进行比较
a:大了
b:小了
c:猜中了
D:给出多次猜的机会，猜中就结束。
while()循环，猜中就break
*/
import java.util.Scanner;
class GuessNumber
{
public static void main(String[] args)
{
int number = (int)(Math.random()*100)+1;
while(true){
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要猜的数据（1-100）：");
int guessNumber = sc.nextInt();
if(guessNumber > number){
System.out.println("你猜的数据"+guessNumber+"大了");
}else if(guessNumber < number){
System.out.println("你猜的数据"+guessNumber+"小了");
}else{
System.out.println("恭喜你，猜中了");
break;
}
}
}
}代码块
代码块
在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块
局部代码块
在方法中出现；限定变量生命周期，及早释放，提高内存利用率
构造代码块
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
静态代码块 在类中方法外出现，加了static修饰
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且值执行一次。
代码：
/*
代码块：在Java中，使用{}括起来的代码被称为代码块。
根据其位置和声明的不同，可以分为
局部代码块:局部位置,用于限定变量的生命周期。
构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前，都会先执行构造代码块。
作用：可以把多个构造方法中的共同代码放到一起，对对象进行初始化。
静态代码块:在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。
作用：一般是对类进行初始化。
面试题?
静态代码块,构造代码块,构造方法的执行顺序?
静态代码块 -- 构造代码块 -- 构造方法
静态代码块：只执行一次
构造代码块：每次调用构造方法都执行
*/
class Code {
static {
int a = 1000;
System.out.println(a);
}
//构造代码块
{
int x = 100;
System.out.println(x);
}
//构造方法
public Code(){
System.out.println("code");
}
//构造方法
public Code(int a){
System.out.println("code");
}
//构造代码块
{
int y = 200;
System.out.println(y);
}
//静态代码块
static {
int b = 2000;
System.out.println(b);
}
}
class CodeDemo {
public static void main(String[] args) {
//局部代码块
{
int x = 10;
System.out.println(x);
}
//找不到符号
//System.out.println(x);
{
int y = 20;
System.out.println(y);
}
System.out.println("---------------");
Code c = new Code();
System.out.println("---------------");
Code c2 = new Code();
System.out.println("---------------");
Code c3 = new Code(1);
}
}面试题 看代码说结果
/*
代码块：在Java中，使用{}括起来的代码被称为代码块。
根据其位置和声明的不同，可以分为
局部代码块:局部位置,用于限定变量的生命周期。
构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前，都会先执行构造代码块。
作用：可以把多个构造方法中的共同代码放到一起，对对象进行初始化。
静态代码块:在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。
作用：一般是对类进行初始化。
面试题?
静态代码块,构造代码块,构造方法的执行顺序?
静态代码块 -- 构造代码块 -- 构造方法
静态代码块：只执行一次
构造代码块：每次调用构造方法都执行
*/
class Code {
static {
int a = 1000;
System.out.println(a);
}
//构造代码块
{
int x = 100;
System.out.println(x);
}
//构造方法
public Code(){
System.out.println("code");
}
//构造方法
public Code(int a){
System.out.println("code");
}
//构造代码块
{
int y = 200;
System.out.println(y);
}
//静态代码块
static {
int b = 2000;
System.out.println(b);
}
}
class CodeDemo {
public static void main(String[] args) {
//局部代码块
{
int x = 10;
System.out.println(x);
}
//找不到符号
//System.out.println(x);
{
int y = 20;
System.out.println(y);
}
System.out.println("---------------");
Code c = new Code();
System.out.println("---------------");
Code c2 = new Code();
System.out.println("---------------");
Code c3 = new Code(1);
}
}Java基础-类