java面向对象
Posted 殷瑜泰
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java面向对象相关的知识，希望对你有一定的参考价值。
成员变量和局部变量的区别：
A:在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
C:生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
注意事项：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
demo： |
class Varialbe { //成员变量 //int num = 10; int num; //0
public void show() { //int num2 = 20; //局部变量 //可能尚未初始化变量num2 //int num2; //没有默认值 int num2 = 20; System.out.println(num2);
//int num = 100; System.out.println(num); } }
class VariableDemo { public static void main(String[] args) { Varialbe v = new Varialbe();
System.out.println(v.num); //访问成员变量
v.show();
} } |
形式参数是类名：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
//形式参数是基本类型
class Demo {
public int sum(int a,int b) {
return a + b;
}
}
//形式参数是引用类型
class Student {
public void show() {
System.out.println("我爱学习");
}
}
class StudentDemo {
//如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
public void method(Student s) { //调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
s.show();
}
}
class ArgsTest {
public static void main(String[] args) {
//形式参数是基本类型的调用
Demo d = new Demo();
int result = d.sum(10,20);
System.out.println("result:"+result);
System.out.println("--------------");
//形式参数是引用类型的调用
//需求：我要调用StudentDemo类中的method()方法
StudentDemo sd = new StudentDemo();
//创建学生对象
Student s = new Student();
sd.method(s); //把s的地址给到了这里
}
}
匿名对象：
就是没有名字的对象
匿名对象的应用场景：
A:调用方法，仅仅只调用一次的时候。
注意：调用多次的时候，不适合。
那么，这种匿名调用有什么好处吗?
有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
B:匿名对象可以作为实际参数传递
demo： |
class Student { public void show() { System.out.println("我爱学习"); } }
class StudentDemo { public void method(Student s) { s.show(); } }
class NoNameDemo { public static void main(String[] args) { //带名字的调用 Student s = new Student(); s.show(); s.show(); System.out.println("--------------");
//匿名对象 //new Student(); //匿名对象调用方法 new Student().show(); new Student().show(); //这里其实是重新创建了一个新的对象 System.out.println("--------------");
//匿名对象作为实际参数传递 StudentDemo sd = new StudentDemo(); //Student ss = new Student(); //sd.method(ss); //这里的s是一个实际参数 //匿名对象 sd.method(new Student());
//在来一个 new StudentDemo().method(new Student()); } } |
封装的概述：
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
封装原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
demo： 定义一个学生类： 成员变量：name，age 成员方法：show()方法
我们在使用这个案例的过程中，发现了一个问题： 通过对象去给成员变量赋值，可以赋值一些非法的数据。 这是不合理的。 应该是这个样子的：在赋值之前，先对数据进行判断。 判断到底在哪里做比较合适呢? StudentDemo类是一个测试类，测试类一般只创建对象，调用方法。 所以，这个判断应该定义在Student类中。 而我们在成员变量的位置可不可以进行数据判断呢? 是不可以的，因为做数据校验，必须要依靠一些逻辑语句。 逻辑语句是应该定义在方法中的，所以，我们最终决定在Student类中提供一个方法 来对数据进行校验。
按照我们前面的分析，我们给出了一个方法进行校验。 但是呢，它偏偏不调用方法来赋值，还是直接赋值了， 这样我们的方法就没有起到作用。 我就应该要求你必须使用我的方法，而不能直接调用成员变量赋值。 怎么去强制要求不能直接使用成员变量呢? 针对这种情况，Java就提供了一个关键字 private
private:私有的。可以修饰成员变量和成员方法。 注意：被private修饰的成员只能在本类中访问。
|
class Student { //姓名 String name; //年龄 private int age;
//写一个方法对数据进行校验 /* 返回值类型：void 参数列表：int a */ public void setAge(int a) { if(a < 0 || age > 120) { System.out.println("你给的年龄有问题"); }else { age = a; } }
//show()方法,显示所有成员变量值 public void show() { System.out.println("姓名："+name); System.out.println("年龄："+age); } }
class StudentDemo { public static void main(String[] args) { //创建学生对象 Student s = new Student(); s.show(); System.out.println("--------------");
//给成员变量赋值 s.name = "林青霞"; //s.age = 27; s.setAge(27); s.show(); System.out.println("--------------");
//给age赋值 //s.age = -27; //这个数据是不合理的 //通过方法给值 s.setAge(-27); s.show(); System.out.println("--------------"); } } |
private关键字：
是一个权限修饰符。
可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。
private最常见的应用：
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
demo： 封装和private的应用： A:把成员变量用private修饰 B:提高对应的getXxx()和setXxx()方法
|
//定义学生类 class Student { //姓名 private String name; //年龄 private int age;
//姓名获取值 public String getName() { return name; }
//姓名设置值 public void setName(String n) { name = n; }
//年龄获取值 public int getAge() { return age; }
//年龄赋值 public void setAge(int a) { age = a; } }
//测试类 class StudentTest { public static void main(String[] args) { //创建学生对象 Student s = new Student();
//使用成员变量 //错误：被私有修饰了，外界不能直接访问了 //System.out.println(s.name+"---"+s.age); System.out.println(s.getName()+"---"+s.getAge());
//给成员变量赋值 //s.name = "林青霞"; //s.age = 27; //通过方法给赋值 s.setName("林青霞"); s.setAge(27); System.out.println(s.getName()+"---"+s.getAge()); } } |
this关键字：
this:是当前类的对象引用。简单的记，它就代表当前类的一个对象。
注意：谁调用这个方法，在该方法内部的this就代表谁。
this的场景：
解决局部变量隐藏成员变量
Demo： |
//定义学生类 class Student { //姓名 private String name; //年龄 private int age;
//姓名获取值 public String getName() { return name; }
//姓名设置值 public void setName(String name) { //name = "林青霞"; //name = name; //变量的使用规则：就近原则 //这里是类名，目前还没有说过类似的用法，所以这个是有问题的 //这里的调用只能通过对象名 //这个对象如果存在，它应该代表的是Student的一个对象。 //那么，谁能够代表当前类的对象呢? java就提供了一个关键字 this //Student.name = name; this.name = name; }
//年龄获取值 public int getAge() { return age; }
//年龄赋值 public void setAge(int age) { this.age = age; } }
//测试类 class StudentTest { public static void main(String[] args) { //创建学生对象 Student s = new Student();
//给成员变量赋值 s.setName("林青霞"); s.setAge(27); //获取数据 System.out.println(s.getName()+"---"+s.getAge()); } } |
构造方法概述和格式：
A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
给成员变量赋值有两种方式：
A:setXxx()
B:构造方法
demo： |
class Student { private String name; private int age;
public Student() { //System.out.println("我给了，你还给不"); System.out.println("这是无参构造方法"); }
//构造方法的重载格式 public Student(String name) { System.out.println("这是带一个String类型的构造方法"); this.name = name; }
public Student(int age) { System.out.println("这是带一个int类型的构造方法"); this.age = age; }
public Student(String name,int age) { System.out.println("这是一个带多个参数的构造方法"); this.name = name; this.age = age; }
public void show() { System.out.println(name+"---"+age); } }
class ConstructDemo2 { public static void main(String[] args) { //创建对象 Student s = new Student(); s.show(); System.out.println("-------------");
//创建对象2 Student s2 = new Student("林青霞"); s2.show(); System.out.println("-------------");
//创建对象3 Student s3 = new Student(27); s3.show(); System.out.println("-------------");
//创建对象4 Student s4 = new Student("林青霞",27); s4.show(); } } |
类初始化的过程：
static关键字：
static的特点：(它可以修饰成员变量，还可以修饰成员方法)
A:随着类的加载而加载
回想main方法。
B:优先于对象存在
C:被类的所有对象共享
举例：咱们班级的学生应该共用同一个班级编号。
其实这个特点也是在告诉我们什么时候使用静态?
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
举例：
饮水机(用静态修饰)
水杯(不能用静态修饰)
D:可以通过类名调用
其实它本身也可以通过对象名调用。
推荐使用类名调用。
静态修饰的内容一般我们称其为：与类相关的，类成员
demo： static关键字注意事项 A:在静态方法中是没有this关键字的 如何理解呢? 静态是随着类的加载而加载，this是随着对象的创建而存在。 静态比对象先存在。 B:静态方法只能访问静态的成员变量和静态的成员方法 静态方法： 成员变量：只能访问静态变量 成员方法：只能访问静态成员方法 非静态方法： 成员变量：可以是静态的，也可以是非静态的 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。 简单记： 静态只能访问静态。
|
class Teacher { public int num = 10; public static int num2 = 20;
public void show() { System.out.println(num); //隐含的告诉你访问的是成员变量 System.out.println(this.num); //明确的告诉你访问的是成员变量 System.out.println(num2);
//function(); //function2(); }
public static void method() { //无法从静态上下文中引用非静态 变量 num //System.out.println(num); System.out.println(num2);
//无法从静态上下文中引用非静态 方法 function() //function(); function2(); }
public void function() {
}
public static void function2() {
} }
class TeacherDemo { public static void main(String[] args) { //创建对象 Teacher t = new Teacher(); t.show(); System.out.println("------------"); t.method(); } } |
main方法的格式详解：
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
demo： |
class MainDemo { public static void main(String[] args) { //System.out.println(args); //[Ljava.lang.String;@175078b //System.out.println(args.length); //0 //System.out.println(args[0]); //ArrayIndexOutOfBoundsException
//接收数据后 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]); } } } |
帮助文档的制作和使用：
如何制作一个说明书呢?
A:写一个工具类
B:对这个类加入文档注释
怎么加呢?
加些什么东西呢?
C:用工具解析文档注释
javadoc工具
D:格式
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:右边
看方法名：方法名称不要写错
参数列表：人家要什么，你就给什么；人家要几个，你就给几个
获取1到100之间的随机数
class MathDemo {
public static void main(String[] args) {
//获取一个随机数
//double d = Math.random();
//System.out.println(d);
//需求：我要获取一个1-100之间的随机数，肿么办?
for(int x=0; x<100; x++) {
int number = (int)(Math.random()*100)+1;
System.out.println(number);
}
}
}
java中的Math类：
demo： 猜数字小游戏(数据在1-100之间) 分析： A:程序产生一个随机数。(被猜的) B:键盘录入数据。(你猜的) C:把你猜的和被猜的进行比较 a:大了 b:小了 c:猜中了 D:给出多次猜的机会，猜中就结束。 while()循环，猜中就break
|
class GuessNumber { public static void main(String[] args) { //程序产生一个随机数。(被猜的) int number = (int)(Math.random()*100)+1; //System.out.println(number);
//给出多次猜的机会，猜中就结束。 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中，使用{}括起来的代码被称为代码块
代码块：在Java中，使用{}括起来的代码被称为代码块。
根据其位置和声明的不同，可以分为
局部代码块:局部位置,用于限定变量的生命周期。
构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前，都会先执行构造代码块。
作用：可以把多个构造方法中的共同代码放到一起，对对象进行初始化。
静态代码块:在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。
作用：一般是对类进行初始化。
demo： |
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面向对象的主要内容，如果未能解决你的问题，请参考以下文章 |