Java面向对象
一、概述
-
面向过程思想概述
一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。代表语言：C语言 -
面向对象思想概述
当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了。这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。 -
面向对象思想特点
a:是一种更符合我们思想习惯的思想
b:可以将复杂的事情简单化
c:将我们从执行者变成了指挥者角色发生了转换 -
举例
洗衣服：换下脏衣服—找盆接水—泡一泡—手搓-----漂清----晾干
面向对象：找个对象（洗衣服）、全自动洗衣机（一键洗衣（调用方法）） -
面向对象特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism) -
面向对象开发
就是不断的创建对象，使用对象，指挥对象做事情
二、类
类就是一组相关属性和功能的集合，对象是该类事物的实例化，例如：学生的实例化之一为班长，班长就是学生类的一个对象
-
成员变量和成员方法
定义类其实就是定义类的成员(成员变量和成员方法)
-
类的使用
A:文件名问题
在一个java文件中写两个类：一个基本的类，一个测试类。
建议：文件名称和测试类名称一致。
B:如何使用呢?
创建对象使用。
C:如何创建对象呢?
格式：类名 对象名 = new 类名();
D:如何使用成员变量呢?
格式：对象名.变量名
E:如何使用成员方法呢?
格式：对象名.方法名(…) -
案例
定义一个手机类并使用
//定义类 public class Phone { //成员变量：定义在类中，方法外 String name = "小米"; double price = 1000; String color = "白色"; //成员方法 public void call(String name) { System.out.println("给" + name + "打电话"); } public void sendMsg(String name, String content) { System.out.println("给" + name + "发短信，内容是" + content); } } //使用该类 public class TestPhone { public static void main(String[] args) { //类是一个抽象的概念，你无法直接使用，要使用类中的属性功能，必须创建该类对象 Phone phone=new Phone(); //获取属性 对象名.属性名 String name=phone.name; double price = phone.price; String color = phone.color; System.out.println(name); System.out.println(price); System.out.println(color); //使用功能：对象名.方法名() phone.call("张三"); phone.sendMsg("张三","生日快乐"); } } -
一个对象的内存图
-
二个对象的内存图
-
三个引用二个对象的内存图
三、成员变量和局部变量的区别
-
在类中的位置不同
成员变量：定义在类中方法外
局部变量：定义在方法中或方法声明上（形参）
-
在内存位置不同
成员变量：在堆内存中
局部变量：在栈内存中
-
生命周期不同
成员变量：随对象的创建而存在，随对象的消失而消失
局部变量：随方法的调用而存在，随方法的弹栈而消失
-
初始化值不同
成员变量：有默认初始化值
局部变量：无默认初始化值，必须赋值才能使用
-
注意事项：局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则
四、方法的形式参数是类名的时候如何调用
- Java中参数传递问题
形式参数
基本类型（四类八种）：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数 - 方法的参数是类名
如果一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
五、匿名对象的概述和应用
- 匿名对象就是没有名字的对象
- 应用场景：对象的方法仅使用一次，也可作实际参数传递
public static void main(String[] args) {
//匿名对象调用方法
new Teacher().show(); //每new一次就是一个新的对象
new Teacher().show2();
new Teacher().show();
new Teacher().show();
//匿名对象调用成员变量
int num = new Teacher().num;
System.out.println(num);
}
public class MyTest {
public static void main(String[] args) {
Cat cat = new Cat();
//如果你以后看到一个方法的形参，要一个 类 类型，那么你就传一个该类对象
cat.show(cat, 19);
System.out.println(cat.num);
System.out.println("---------------------");
//匿名对象作为参数传递
//匿名对象可以作为参数传递
cat.show(new Cat(), 20);
System.out.println(cat.num);
}
}
class Cat {
int num = 100;
public void show(Cat cat, int num) {
cat.num = num;
System.out.println(cat.num);//
}
}
输出：
19
19
---------------------
20
19
六、封装
-
封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式
-
好处
- 隐藏实现细节，提供公共的访问方式
- 提高了代码的复用性
- 提高安全性
-
原则：将不需要对外提供的内容都隐藏起来，提供公共方法对其访问。
七、private关键字
private是一个权限修饰符，可以修饰成员变量和成员方法，被其修饰只能在本类中被访问,提供get和set方法以供外界访问
-
应用
public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void sleep() { System.out.println("睡觉"); } public void eat() { System.out.println("吃饭"); } } public class TestStudent { public static void main(String[] args) { Student student = new Student(); student.setName("张三"); student.setAge(20); String name = student.getName(); int age = student.getAge(); System.out.println("姓名：" + name + "=== 年龄" + age); student.eat(); student.sleep(); System.out.println("-------------------"); Student student1 = new Student(); student1.setName("李四"); student1.setAge(24); String name1 = student1.getName(); int age1 = student1.getAge(); System.out.println("姓名：" + name1 + "=== 年龄" + age1); student1.eat(); student1.sleep(); } } //输出： 姓名：张三=== 年龄20 吃饭 睡觉 ------------------- 姓名：李四=== 年龄24 吃饭 睡觉
八、this关键字
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题
this关键字代表当前类的引用，简单地说就是代表当前类的一个对象，谁调用这个方法，这个方法的内部的this就代表谁
public class TestThis {
public static void main(String[] args) {
A a = new A();
System.out.println(a);
int num=10; //定义在栈内存中
a.show(num,a);
System.out.println(num); //10
}
}
class A{
int num=100; //定义在堆内存中
public void show(int num, A a){
System.out.println(this); //本类引用
System.out.println(num); //10
System.out.println(a.num); //100
System.out.println(this.num); //100
System.out.println(a==this);
}
}
输出：
org.westos.homework0406.A@1540e19d
org.westos.homework0406.A@1540e19d
10
100
100
true
10
九、构造方法
-
作用
创建对象时为对象中的成员进行初始化
-
特点
- 方法名与类名相同
- 么有具体的返回值类型
- 方法声明不写返回值类型，void也不用
-
注意事项
如果没有自定义构造方法，系统会自动提供一个空参构造；若给出了有参构造，系统将不再提供空参构造，如果还需要空参构造，必须手动给出
-
给成员变量赋值的两种方式
a:setXxx()方法
b:构造方法 -
案例
public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void sleep() { System.out.println("睡觉"); } public void eat() { System.out.println("吃饭"); } }
十、创建一个对象的步骤
说明个对象的创建过程做了哪些事情 Student s = new Student();
-
步骤:
(1):加载Student.class文件进内存
(2):在栈内存为s开辟空间
(3):在堆内存为学生对象开辟空间
(4):对学生对象的成员变量进行默认初始化
(5):对学生对象的成员变量进行显示初始化
(6):通过构造方法对学生对象的成员变量赋值
(7):学生对象初始化完毕，把对象地址赋值给s变量 -
内存图：
十一、static关键字
-
案例
public class Person { public String name; //我想让中国这个数据变成共享变量，让这个类的所有对象，都能够共享他 // 我们可以使用一个关键字，static 静态的 可以修饰成员变量，和成员方法 //被static所修饰的成员变量，是一个共享变量，被类的所有对象所共享 //被静态所修饰的成员，是随时类的加载而加载（随着 .class文件进内存，静态的东西就会加载） //优先于对象而存在 public static String country = "中国"; } public class MyTest { public static void main(String[] args) { //想让中国，让这个三个对象共享 Person person = new Person(); person.name="张三"; person.country="美国"; System.out.println("---------------"); Person person2 = new Person(); person2.name = "李四"; person2.country = "新加坡"; System.out.println("---------------"); Person person3 = new Person(); person3.name = "王五"; person3.country = "英国"; System.out.println(person.name+"----"+person.country); //张三---英国 System.out.println(person2.name + "----" + person2.country); //李四---英国 System.out.println(person3.name + "----" + person3.country); //王五---英国 } } -
内存图
-
static关键字的特点
- 随着类的加载而加载
- 可以通过类名调用
- 优先于对象存在
- 被类的所有对象共享
-
注意事项
- 静态方法中不能使用this关键字，this表示本类的引用，即一个对象，而静态是虽类的加载而加载的，静态比对象先存在
- 静态方法只能访问静态成员变量和静态成员方法（静态只能访问静态）
十二、静态变量和成员变量的区别
-
在内存中位置不同
- 静态变量存储在方法区的静态区
- 成员变量存储在堆内存
-
所属不同
- 静态变量属于类（类变量）
- 成员变量属于对象（实例变量/对象变量）
-
生命周期不同
- 静态变量随类的加载而加载，随类的消失而消失
- 成员变量随对象的创建而存在，随对象的消失而消失
-
调用方式不同
- 静态变量既可以通过类名调用，也可以通过对象调用
- 成员变量只能通过对象调用
十 三、Math类的随机数功能
-
Math类包含用于执行基本数学运算的方法，由于Math类在java.lang包下，所以不需要导包。Math类没有构造方法，因为它的成员全部是静态的。
-
获取随机数的方法
public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。若要获取一个1-100之间的随机数，可int number = (int)(Math.random()*100)+1;
-
案例：猜数字小游戏(数据在1-100之间)
import java.util.Scanner; public class RandomGame { public static void main(String[] args) { System.out.println("请输入一个数1~100"); Scanner scanner = new Scanner(System.in); int answer = (int) (Math.random()*100+1); int index = 1; while (index<=10){ int num = scanner.nextInt(); if(num>answer){ System.out.println("猜大了"); System.out.println("你还剩"+(610-index)+"次机会"); index++; }else if(num<answer){ System.out.println("猜小了"); System.out.println("你还剩"+(10-index)+"次机会"); index++; }else { System.out.println("恭喜你，猜对了"); break; } } } }
77
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
