1 概述
面向过程:面向着具体的每一个步骤和过程,把每一个步骤和过程完成,然后由这些功能方法相互调用,完成需求。
面向对象:强调的是对象,是基于面向过程的编程思想。
面向对象思想特点:
A:是一种更符合我们思想习惯的思想
B: 可以将复杂的事情简单化
C: 将我们从执行者变成了指挥者
举例:买电脑
面向过程:了解电脑--了解我的需求--找对应的参数信息--去中关村--讨价还价--买回电脑
面向对象:知道要买电脑--班长去给我买--买回来了
万事万物皆对象
把大象装进冰箱案例:
面向过程:打开冰箱门open()--装进大象in()--关闭冰箱门close()
class DEMO{
public static void main(String[] args){
open();
in();
close();
}
public static void open{
System.out.println("打开冰箱门");
}
public static void in{
System.out.println("装进大象");
}
public static void close{
System.out.println("关闭冰箱门");
}
}
面向对象:(UML,名词提取法)
A:有哪些类呢?
大象、冰箱、DEMO
B:每个类有哪些东西呢?
大象:进去
冰箱:开门、关门
DEMO:main方法
C:类与类之间的关系是什么呢?
DEMO中使用大象和冰箱类的功能
class 大象{
public static void in{
System.out.println("装进大象");
}
}
class 冰箱{
public static void open{
System.out.println("打开冰箱门");
}
public static void close{
System.out.println("关闭冰箱门");
}
}
class DEMO{
public static void main(String[] args){
冰箱调用开门
大象调用进去
冰箱调用关门
}
}
面向对象开发:不断的创建对象,使用对象,指挥对象做事情。
面向对象设计:管理和维护对象之间的关系。
面向对象特征:封装、继承、多态
类与对象:
java中最基本的单位是类。
类:是一组相关的属性和行为的集合,是一个抽象的概念。
对象:是该类事物的具体表现形式,具体存在的个体。
举例:类:学生
对象:班长
2 类
定义一个类其实就是定义类的成员变量和成员方法。
成员变量:和以前变量的定义是一样的格式,但是位置不同,在类中方法外。
成员方法:和以前方法的定义是一样的格式,但是今天把static先去掉。
学生类的定义:
/*
学生类的定义
*/
class StudentDemo{
//定义变量
String name;
int age;
String address;
//定义方法
public void study(){
System.out.println("学生爱学习");
}
public void eat(){
System.out.println("学习饿了要吃饭");
}
public void sleep(){
System.out.println("学习累了要睡觉");
}
}
手机类的定义:
/*
手机类的定义
*/
class PhoneDemo{
//定义变量
String brand;
int price;
String color;
//定义方法
public void call(String name){
System.out.println("给"+name+"打电话");
}
public void sendMessage(){
System.out.println("群发短信");
}
public void playGame(){
System.out.println("玩游戏");
}
}
学生类的使用:
*
在一个java文件中写两个类:一个基本的类,一个测试类。
注意:文件名称和测试名称一致。
*/
//学生类
class Student{
String name; //null
int age; //0
String address; //null
public void study(){
System.out.println("学生爱学习");
}
public void eat(){
System.out.println("学习饿了要吃饭");
}
public void sleep(){
System.out.println("学习累了要睡觉");
}
}
//学生测试类
class StudentUse{
public static void main(String[] args){
//类名 对象名=new 类名();
Student s=new Student();
//输出成员变量值
System.out.println(s.name+"--"+s.age+"--"+s.address);
//给成员变量赋值并输出
s.name="小朋友";
s.age=27;
s.address="北京";
System.out.println(s.name+"--"+s.age+"--"+s.address);
//调用方法
s.study();
s.eat();
s.sleep();
}
}
手机类的使用:
/*手机类的使用*/
class Phone{
//定义变量
String brand;
int price;
String color;
//定义方法
public void call(String name){
System.out.println("给"+name+"打电话");
}
public void sendMessage(){
System.out.println("群发短信");
}
public void playGame(){
System.out.println("玩游戏");
}
}
class PhoneUse{
public static void main(String[] args){
Phone p=new Phone();
//输出成员变量
System.out.println(p.brand+"--"+p.price+"--"+p.color);
//给成员变量赋值并输出
p.brand="华为";
p.price=1000;
p.color="灰色";
System.out.println(p.brand+"--"+p.price+"--"+p.color);
//调用方法
p.call("老大");
p.sendMessage();
p.playGame();
}
}
3 对象
一个对象的内存图
二个对象的内存图:方法共用
三个对象的内存图:其中有两个引用指向同一个对象
成员变量和局部变量的区别:
成员变量 | 局部变量 | |
在类中的位置不同 | 类中方法外 | 方法内或者方法声明上 |
在内存中的位置不同 | 堆内存 | 栈内存 |
声明周期不同 | 随着对象的存在而存在,随着对象的消失而消失 | 随着方法的调用而存在,随着方法的调用完毕而消失 |
初始化值不同 | 有默认的初始化值 | 没有默认的初始化值,必须先定义,赋值,才能使用 |
注意事项:
局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则。
//成员变量和局部变量的区别
class Variable{
//成员变量
//int num=10;
int num;
public void show(){
//int num2=20; //局部变量
//可能尚未初始化变量num2
int num2=20;
System.out.println(num2);
//int num=100;
System.out.println(num);
}
}
class VariableDemo{
public static void main(String[] args){
Variable v=new Variable();
System.out.println(v.num);//0
v.show();//20
}
}
形式参数问题:
基本类型:形式参数的改变不影响实际参数
引用类型:形式参数的改变直接影响实际参数
//形式参数问题
//形式参数是基本类型
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的地址传到了这里
s.show();
}
}
class ArgsTest{
public static void main(String[] args){
//形式参数是基本类型的调用
Demo d=new Demo();
int result=d.sum(10,20);
System.out.println(result);
//形式参数是引用类型的调用
StudentDemo sd=new StudentDemo();
Student s=new Student();
sd.method(s);//把s的地址给到了这里
}
}
匿名对象的概述和应用:
匿名对象:就是没有名字的对象,是对象的一种简化形式
匿名对象的两种使用情况:
A:对象调用方法仅仅一次的时候
调用多次的时候不适合
好处:匿名对象调用完毕就是垃圾,可以被垃圾回收器回收。
B:匿名对象可以作为实际参数传递
/*匿名对象*/
class Student{
public void show(){
System.out.println("我爱学习");
}
}
class StudentDemo{
public void method(Student s){
s.show();
}
}
class NoName{
public static void main(String[] args){
Student s=new Student();
s.show();
//匿名对象
//new Student();
//匿名对象调用方法,仅仅调一次
new Student().show();
new Student().show();//这里其实是重新创建了一个新的对象
//匿名对象作为实际参数传递
StudentDemo sd=new StudentDemo();
//Student ss=new Student();
//sd.method(ss);
//sd.method(new Student());
new StudentDemo().method(new Student());
}
}
封装:
封装概述:指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
封装好处:
A:隐藏实现细节,提供公共的访问方式
B:提高了代码的复用性
C:提高安全性
封装原则:
把不需要对外提供的内容都隐藏起来;把属性隐藏,提供公共方法对其访问。
/*
发现一个问题:
通过对象给成员变量赋值,可以赋值一些非法的数据。这是不合理的。
应该在赋值之前先对数据进行判断。那应该在哪里做判断呢?
StudentDemo是一个测试类,测试类一般只创建对象,调用方法
所以这个判断应该定义在Student中。
做数据校验必须要依靠一些逻辑语句,逻辑语句应该定义在方法中。
这个方法定义了,要求必须使用方法,不能直接调用成员变量值。
这种情况提供了一个关键字:private
private:私有的,可以修饰成员变量和成员方法。
被private修饰的成员只能在本类中访问。
*/
class Student{
String name;
private int age;
//写一个方法对数据校验
public void setAge(int a){
if(a<0 || a>120){
System.out.println("年龄有问题");
}else{
age=a;
}
}
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();
s.name="啦啦啦";
//s.age=27;
s.setAge(27);
s.show();
//s.age=-27;//这个数据是不合理的
s.setAge(30);
s.show();
}
}
private关键字:
是一个权限修饰符,可以修饰成员(成员变量和成员方法),被private修饰的成员只能在本类中才能访问。
常见的应用:
把成员变量用private修饰;提供对应的getXxx()或setXxx()方法。
class Demo{
//私有的成员变量
private int num=10;
public void show(){
System.out.println(num);
}
//私有的成员方法
private void method(){
System.out.println("method");
}
public void function(){
method();
}
}
class PrivateDemo{
public static void main(String[] args){
Demo d=new Demo();
//d.num; //报错
d.show();
//d.method(); //报错
d.function();
}
}
private常见应用:
class Student{
private String name;
private int age;
//获取值
public int getAge(){
return age;
}
public String getName(){
return name;
}
//赋值
public void setName(String n){
name=n;
}
public void setAge(int a){
age=a;
}
}
class PrivateTest{
public static void main(String[] args){
Student s=new Student();
//System.out.println(s.name); //外界不能直接访问
System.out.println(s.getName()+"--"+s.getAge());
//给成员变量赋值
s.setAge(27);
s.setName("我");
System.out.println(s.getName()+"--"+s.getAge());
}
}