一 类和对象的概念
1.对象
在Java中,对象具有属性和方法.属性为对象的一般特征(抽象描述),方法为对象的一些行为.(对象是由类创建出来的具体的事物)
例如用对象描述一个程序员
属性: 姓名 性别 年龄
方法(行为): 吃饭,睡觉,敲代码
2.类
java中最基本的单位就是类.类是一堆抽象事物的描述(模板).也可以说类是具有相同属性和方法(行为)的一组对象的集合.当然,类也具有属性和方法.
3.类与对象的关系
可以说类是一组具体事物的相同特征(属性)和行为(方法)的抽象描述,而对象即为类中的每一个具体事物.
二 面向对象概念以及好处
1.面向过程
说面向对象之前先大致理解下面向过程.见名知意,面向过程的重点就在过程中,比如说在过程中做什么,也可以说是事务的执行者
例如挑选一个电脑
这个过程中,我们就要挑他的CPU,主板,显示器等并执行.
2.面向对象
由名称也可看出其重点在对象.就如做什么事,我们考虑的是找谁做.由事务的执行者变成了指挥者.
就如上个买电脑的例子.买电脑,我们不需要挑电脑的软硬件,而是仅仅需要找一个懂电脑的人帮我们去买就可以了.
可以说面向对象是一个贴近与人的思维(懒人思维).
3.面向对象的好处:
①将复杂问题简单化
②从事务的执行者 转化为 事务的指挥者
③更贴近于人的思维(懒人思维)
三 创建一个类(为力量创建一个抽象类的具体对象)
例如创建一个学生类
class Student{
//属性书写位置(成员变量 实例变量)
//书写位置:类中方法外
//行为(方法 函数) 跟函数一样 就static先不写
//书写位置:类中
String name;
int age;
String gender;
//成员方法/实例方法
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
public void play(String game) {
System.out.println("打游戏" + game);
}
//介绍自己的方法(行为):
public void sayHi() {
System.out.println("姓名:" + name);
System.out.println("年龄:" + age);
System.out.println("性别:" + gender);
}
}
而创建类都是为了创建一个对象
public static void main(String[] args) {
//创建一个学生类的对象出来
//类型名 对象名 = 初值;
//成员变量会随对象一起进入堆中
//new 一次,就会在堆中开辟一块内存空间
//Student stu 对象的引用(保存的是对象的地址)
Student stu = new Student();
//使用 对象名.属性名 进行赋值和取值
stu.name = "fas";
stu.name = "fa";
stu.age = 24;
stu.gender = "男";
//调用成员方法 对象名.方法名
stu.eat();
stu.play("英雄联盟");
//那个对象调用该方法,打印的就是那个对象的属性
stu.sayHi();
//不new没有开辟一个新的空间,对同一个进行数据操作
Student stu1 = stu;
stu1.name = "fasf";
stu.sayHi();
}
而上述所说的成员变量和局部变量可看这个例子
package com.lanou3g;
/*
* 车类:
* 车名 排气量 颜色
* 开车
* 停车
*/
class car{
//声明成员变量的时候 可以给初值
String name = "法拉利";//车名
String displacement = "8.0T";//排气量
String color = "红色";//车颜色
public void startcar(int a) {//方法上
//在方法中的变量,是局部变量
//在方法上的变量,是局部变量
int num = 0;
//就近原则
String color = "红色";
System.out.println(color);
System.out.println("开车");
}
public void stopcar() {
System.out.println("停车");
}
public void sayHi() {
System.out.println("名字:" + name);
System.out.println("排气量:" + displacement);
System.out.println("车颜色:" + color);
}
}
成员变量和局部变量的区别
1.书写位置
成员变量:类中方法外
局部变量:方法中或方法上
2.在内存中的表现
成员变量:堆内存
局部变量:栈内存
3.生命周期
成员变量:随着对象进入堆内存中创建,随着对象的销毁而销毁
局部变量:随着方法的调用入栈,随着方法的结束而销毁
4.作用域
成员变量:整个类中
局部变量:方法中
5.初始值
成员变量:跟堆内存一样,有默认初始值
局部变量:不给初值,直接编译报错
在创建对象的时候,如若创建不同包下下的同名类的对象,需要指定完整的包名来创建对象
而创建不同包下的不同名类的对象,
四 创建对象时参数的引用
public class Demo04 {
//参数是基本数据类型
public static void fun1(int a) {
System.out.println(a);
a = 10;
}
//参数是引用数据类型
//要什么类型 就给什么类型
public static void fun2(Person p) {
p.name = "文武";
p.age = 24;
}
public static void main(String[] args) {
int a = 100;
fun1(a);
System.out.println(a);
Person p1 = new Person();
p1.name = "雨竹";
p1.age = 28;
fun2(p1);
p1.sayHi();
}
}
数据的操作过程为
所以打印出来的是
五 匿名对象
匿名对象(没有名字的对象):
1.在方法传参数的时候使用
2.只调用一下方法(不赋值的情况下)
public class Demo05 {
public static void setNameAndAge(Person p, String name, int age) {
p.name = name;
p.age = age;
p.sayHi();
}
public static void main(String[] args) {
//创建两个person对象 并赋值
//将重复代码 抽成一个方法
Person p1 = new Person();
p1.name = "wanglong";
p1.age = 16;
p1.sayHi();
Person p2 = new Person();
setNameAndAge(p2, "menglong", 8);
//使用匿名对象 当方法参数
//好处:减少代码量 使用方便
setNameAndAge(new Person(), "kun", 20);
//匿名对象也是对象,也可以赋值属性,调用同样的方法
new Person().name = "xin";//xin 0
new Person().age = 30;// null 30
new Person().sayHi();// null 0
//new 在堆内存中开辟空间,所以打印了三个空间
//只调用方法可以使用匿名对象-----测试方法时,可能会使用
new Person().fun();
}
}
所以其打印的结果为
六 封装
写方法就是封装的一种,相当于隐藏代码的实现和属性 不能随意修改
需要开放访问方式(方法) 获取 修改
好处:
1.提高代码的复用性
2.提高代码的安全性
关键字(权限修饰符)
private 私有的
被private修饰的属性 只能本类中访问
public class Demo06 {
public static void main(String[] args) {
Phone phone = new Phone();
//测试 set get方法
phone.setPhoneName("vivo");
phone.setColor("红色");
System.out.println(phone.getPhoneName());
System.out.println(phone.getColor());
phone.sayHi();
}
}
class Phone{
//java bean 对象(java 实体类创建出来的对象)
//1.声明成员变量 都需要 私有化
//2.给每一个成员变量提供 set/get方法
//3.必须提供 无参的构造方法
private String phoneName;
private String color;
//对外开放 访问方式
//获取方法 get
//命名规范
// 获取 get + 成员变量名(首字母大写)
// 修改 set + 成员变量名(首字母大写)
// 标准写法 set方法 没有返回值的
public String getPhoneName() {
return phoneName;
}
public String getColor() {
return color;
}
//修改方法(设置方法) set
public void setPhoneName(String name) {
phoneName = name;
}
public void setColor(String color) {
//就近原则
//关键字 this 代表的诗 本类的对象
//this.成员变量 = 获取 本类的 成员变量
//this.成员变量 = "哈啊哈";给本类的成员变量赋值
//this.成员方法 调用本类的成员方法
//谁调用了这个方法,谁就是这个this
this.color = color;
}
public void sayHi() {
System.out.println(phoneName + " " + color);
}
}
打印结果
七 有无参数的构造方法
/*
* 构造方法:对 对象的成员变量进行初始化
* 写法:
* 1.没有返回值类型位置(连void都不写)
* 2.构造方法方法名 要与 类名 完全一致
*/
public class Demo07 {
public static void main(String[] args) {
//创建一个pen对象
//构造方法 是系统帮你调的
//只要你创建对象 系统就会帮你调用构造方法
//构造方法 只会执行一遍
Pen pen = new Pen();
pen.sayHi();
/* pen.setName("作弊笔");
pen.setColor("红色");
System.out.println(pen.getName());
System.out.println(pen.getColor());*/
//测试有参的构造方法
//传参数 系统就会去找你有参的构造方法调用
Pen pen2 = new Pen("钢笔", "绿色");
pen2.sayHi();
/*
* 类中写什么?
* 成员变量
* 无参构造方法
* 有参构造方法
* 成员方法
* set/get方法
*/
}
}
class Pen{
/*
* 类中的书写顺序
* 1.成员变量
* 2.构造方法
* 3.成员方法
* 4.set/get
*/
private String name;
private String color;
//构造方法(无参)
public Pen() {
//初始化成员变量(给成员拜变量赋值)
this.name = "圆珠笔";
this.color = "绿色";
System.out.println("我是pen类的无参构造方法");
}
//有参的构造方法(构造方法的重载)
//为了再创建对象的同时 给成员变量赋值
public Pen(String name,String color) {
this.name = name;
this.color = color;
System.out.println("我是有参的构造方法");
}
//介绍自己的方法
public void sayHi() {
//使用this可以区分 成员变量 和 局部变量
System.out.println(this.name + " " + this.color);
}
//set/get方法
public void setName(String na) {
name = na;
}
public void setColor(String col) {
color = col;
}
public String getName() {
return name;
}
public String getColor() {
return color;
}
}
打印结果为
