大纲
面向对象-1,-2
你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章,了解一下Markdown的基本语法知识。
1.面向对象的概念
思想:能够让人们普遍接受的思维方式。比如:毛泽东思想
1.面向过程:凡是必躬亲!!自己的事情自己一步步完成。 典型的语言:C语言
2.面向对象:懒人思维,自己的事情交给别人来做。 典型的语言:Java
-- 面向对象举例:
1.洗衣服:
面向过程:脱衣服 ,把衣服放入水盆,倒入水和洗衣液,揉一揉,搓一搓,拧一拧,晾一晾。
面相对象:脱下衣服放入洗衣机,倒入洗衣液,按启动按钮。 对象是:洗衣机
2.买电脑:
面向过程:来到广埠屯,找到卖电脑的店面,挑选配置,谈价格,打的送电脑回家。
面向对象:躺在床上,使用手机打开京东,挑选电脑,下单,收货。对象是:手机
面向对象的三个特点:
1.更符合人们的思维习惯(懒人思维)
2.让复杂的事情简单化,让简单的事情更加简单
3.将自己的事情交由别人做,由执行者变成了指挥者,通过对象.方法()
服务员点单?
15字总结面向对象:
服务员点单
万物皆对象
对象调方法
面试官:什么是面向对象?
面试官,您好!我理解的面向对象是:更加符合人们的思维习惯,让复杂的事情简单化,让我们从执行者变成指挥者。我之前在Java编程思想中了解到面向对象是:万物皆对象,例如:您这次面试我,就存在面向对象的思想。
您来面试我,想必是公司有开发需求需要完成,以您的实力,完全可以一个人完成,但是呢,您有更加重要的事情需要去完成,所以您需要招到一个具备开发能力的人帮您完成。例如:我
3.面向函数:忽略对象,只看结果/功能。Jdk1.8的新特性:Lambda表达式
2.类和对象
类:是一类事物的抽象/统称。 例如:狗 是所有狗的统称 类称为图纸
类的组成:属性和行为
属性:共有的特性。比如:姓名 , 年龄 , 体重
行为:共有的功能。比如:看家,睡觉,吃饭
类的作用:是用来描述事物的。
对象:是类的实例。 例如:我家的黄色皮肤,年龄2岁名字叫旺财的中华田园犬 对象称为实例
类和对象的关系:类是对对象的描述,对象是类的实例
3.面向对象编程
3.1 定义一个事务描述类
public class Phone {
//1.属性 / 成员变量
/**
* 格式:
* 权限修饰符 数据类型 属性名称 ;
* <p>
* <p>
* 注意:一般情况下不会给属性复制,系统会给它默认值
*/
public String color;
public String brand;
public int price;
//2.行为 / 成员方法
/**
* 格式:
* 权限修饰符(一般没有static修饰) 返回值类型 方法名(形式参数列表){
* 方法体;
* return 返回值 ;
* }
*/
public void call() {
System.out.println("打电话");
}
public void sendMessage(String message) {
System.out.println("小王正在使用颜色为:" + color + ",品牌为:" + brand + ",价格为:" + price + "的手机发送:" + message);
}
}
3.2通过对象调用属性和行为(生产出具体的手机)
/**
* 手机的测试类
*/
public class TestPhone {
public static void main(String[] args) {
/**
* 创建手机对象的格式:
*
* Scanner sc = new Scanner(System.in);
*
* 类名 对象名 = new 类名(实际参数); 调用了Phone类中的哪一个参数?
*/
Phone p1 = new Phone();
/**
* 使用对象调属性
* 格式: 对象名.属性名
*/
System.out.println(p1.color);//null
System.out.println(p1.brand);//null
System.out.println(p1.price);//0
System.out.println("-------------------------------");
/**
* 给属性赋值
* 格式: 对象名.属性名 = 属性值;
*/
p1.color = "黑色";
p1.brand = "华为P80";
p1.price = 10000;
System.out.println(p1.color);//黑色
System.out.println(p1.brand);//华为P80
System.out.println(p1.price);//10000
/**
* 调用方法
* 格式:变量类型 变量名称 = 对象名.方法名(实际参数);
*/
p1.call();
p1.sendMessage("宝 我今天去输液了~");
}
}
3.3 成员变量和局部变量的区别
1.成员变量:在类中方法外
局部变量:在方法中
2.成员变量作用范围:在整个类的大括号中都有效,包括方法。
局部变量作用范围:只能在当前的方法大括号内有效,出来方法大括号就失效。
3.成员变量:存在于堆内存中。
局部变量:存在于栈内存中。
4.成员变量:不给它赋值,会有它对应的类型的默认值。
局部变量:不给它赋值,没有默认值。
5.成员变量生命周期:当new对象的时候出生,当由GC机制空闲回收时,销毁成员变量。
局部变量生命周期:当方法被调用时,出生,当方法执行完毕,弹栈时销毁。
口诀:因为…所以…
1.因为成员变量在类中方法外,局部变量在方法中,所以成员变量在整个类中都有效,局部变量只在其存在的方法中才有效。 1 ----> 2
2.因为成员变量存在于堆内存中,局部变量存在于栈内存中,所以成员变量有默认值,而局部变量没有。
3.因为成员变量存在于堆内存中,局部变量存在于栈内存中,所以成员变量随着对象的创建而出生,当GC机制回收时销毁,局部变量当方法调用时创建,方法执行完毕,弹栈时销毁。
6.颜色不一样:在Idea中,当成员变量和局部变量都没有被使用时,都是灰色,但是当成员变量被使用时是紫色,当局部变量被使用时是细黑色。
4.构造方法
构造方法的作用:
无参构造方法:
1.作用:帮我们创建对象,对象中属性是默认值。
2.格式:权限修饰符 方法名/类名(){}
3.注意:当事物描述类中没有写任何构造方法时,系统会免费提供一个无参构造方法
有参构造方法:
1.作用:帮我们创建对象,对象中属性值赋值为方法中的实际参数值。
2.格式:权限修饰符 方法名/类名(形式参数列表){
成员变量位置的属性赋值;
}
3.注意:形式参数的类型必须和属性对应。
优先级:局部变量>成员变量 ,方法中的局部变量和成员变量如果名字相同,在方法中使用的是局部变量。
4.当局部变量和成员变量名字相同,可以使用this.变量名强制指向成员变量,如果不用this.就优先采用局部变量。
构造方法的重载
重载概念:方法名相同,形式参数列表不同,与其他无关。
public Dog() {//当事物描述类中没有写任何构造方法时,系统会免费提供一个无参构造方法
//System.out.println(“我自己的:无参构造方法执行”);
}
/**
* 定义有参构造方法
* 权限修饰符 方法名/类名(形式参数列表){
* 将成员变量的值赋值为对应的形式参数列表的值
* }
*/
public Dog(String name, int age) {
this.name = name;//this.name能帮我们强制只想成员变量位置的name
this.age = age;
}
public Dog(String name) {
this.name = name;
}
public Dog(int age) {
this.age = age;
}
匿名对象
概念:创建出对象,但是没给对象取名字。
int num = new Random().nextInt(10);
int num2 = new Random().nextInt(10);
/**
* new Random() : 匿名对象 为了简单
* 使用场景:1.当这个对象只使用一次时,为了方便可以使用匿名对象
* 2.匿名对象还可以作为方法的实际参数传入 -- 常用
*/
Student student = new Student();
student.printBeautiful(new Scanner(System.in));
public void printBeautiful(Scanner sc){//Scanner sc = Xo001
int[] arr = new int[2];
System.out.println("请录入整数");
int num = sc.nextInt();
System.out.println("请录入整数");
int num2 = sc.nextInt();
arr[0] = num;
arr[1] = num2;
System.out.println(Arrays.toString(arr));
}
构造方法和成员方法的区别:
区别一:定义格式区别
构造函数的方法名要与类名一样,并且没有返回值这个项目,因为都是返回的这个类对应的对象。
成员方法的方法名只需符合小驼峰命名法,必须定义返回值类型。
区别二:调用时期区别
构造方法在实例化对象的时候调用。 new 对象类型(形式参数列表)时调用。
成员方法在对象创建成功之后调用。 对象名.成员方法名(形式参数列表);
区别三:调用方式区别
构造方法通过new关键字来调用。
成员方法通过对象来.调用。
区别四:调用次数区别
同一个对象构造方法只能调用一次,在创建对象的时候调用。
成员方法可以调用任意多次!
注意:构造方法中可以调用成员方法,同一个对象中,构造方法的执行,早于成员方法。
5.setter () 和getter()方法:
权限修饰符:public protected default private
分类:
public :公共的,共享
protected :受保护的
default(不写) :默认的
private :私有的,自己可以用,不给其他类用
作用范围:
public > protected > default > private
重点研究:public 和 private
private:
作用:保护类中的成员变量和成员方法,但是我们一般只用private修饰成员变量。
功能:被private修饰的成员不能被其他类直接访问。但是可以间接访问。 --->使用getter() 和 setter() 访问
效果:可以提高程序的安全性。
6.this关键字
this:本类对象的引用,只在事物描述类中出现。
this一般在事物描述类的:setter() 和 有参构造方法中出现,作用就是给成员变量赋值实际参数值。
有参构造 == 无参构造 + setter();
this.成员变量:强制性调用成员变量。
this.成员方法:一般省略this. ,因为不可能有局部方法,只会找成员方法。
this.构造方法:只能在构造方法中调用,并且只能在第一行。
结论:谁调用了this所在的方法,this就代表谁。
照镜子:谁去照这个镜子,镜子里面就是谁。
7.static关键字
static:静态的,公共的。
static使用的4个特点:
1.被static修饰的成员,被所有的对象所共享。
2.被static修饰的成员,可以用类名直接调用。
3.被static修饰的成员,不属于对象,属于类。
4.被static修饰的成员,优先于对象,随着类的加载而加载。
static修饰的成员的访问特点:
总结:静态成员方法只能访问静态成员,非静态成员方法都可以访问。
public class Cat {
//成员变量
public String name; //非静态的成员变量
public static int age; //静态的成员变量
//成员方法
public void sleep() { //非静态的成员方法
System.out.println("睡觉");
}
public static void eat() { //静态的成员方法
System.out.println("吃");
}
//非静态的成员方法:可以访问静态和非静态的成员,畅通无阻
public void method(){
System.out.println(name);// 访问非静态的成员变量 ok
System.out.println(age);// 访问静态的成员变量 ok
sleep(); //访问非静态成员方法 ok
eat(); //访问静态的成员方法 ok
}
//静态的成员方法:只能访问静态。
public static void staticMethod(){
//System.out.println(name);// 访问非静态的成员变量 不ok
System.out.println(age);// 访问静态的成员变量 ok
//sleep(); //访问非静态成员方法 不ok
eat(); //访问静态的成员方法 ok
}
}
静态变量和成员变量区别
区别一:生命周期不同
成员变量随着对象的创建而创建,随着对象的回收而释放。
静态变量随着类的第一次加载而存在,随着类的消失而消失。
区别二:调用方式不同
成员变量只能被对象调用。
静态变量可以被类名调用,也可以被对象调用。
区别三:数据存储位置不同
成员变量存储在堆中,也称为对象的特有数据。
静态变量存储在方法区(共享数据区)的静态区,也称为对象的共享数据。
区别四:创建次数不同
成员变量可以创建任意多次,每创建一次对象就创建了一次成员变量。
静态变量只能创建一次,被该类和该类的对象所共享。
静态代码块
1、构造方法:当对象创建时,执行构造方法,对象每创建一次执行一次。
2、构造代码块:在对象创建之前执行,没创建一个对象执行一次。
3、静态代码块:当类第一次加载时执行,只执行一次。
执行顺序:静态代码块 > 构造代码块 > 构造方法
8.封装
面向对象三大特性:封装,继承,多态
封装:将一个事物描述类中的成员,包括成员变量和成员方法,通过一个实例化对象体现出来。
封装的四种情况:
循环语句:提高代码的复用性。
方法:提高代码的复用性,可以通过传入实际参数,提高代码的灵活性。
private:提高了代码的安全性。
对象的封装:提高了代码的多样性。
9. JavaDoc生成API文档
见脑图