Day06JavaSE——类与对象
c:构造方法 通过对象直接访问成员变量是不被允许的,这样会导致一些未知的错误,所以在日常使用时,我们将成员变量通常设置成private权限,这样就不能在成员变量所在类外去通过对象直接调用成员变量,我们通过一个成员变量建立两个类来对成员变量进行赋值与调用
面向类的思想
类与对象及其应用
如何创建标准Java类库中的类对象
如何编写自己的类
对象的内存图
成员变量和局部变量的区别
匿名对象
封装(private)
this关键字
面向对象概述
在了解什么是面向对象之前首先要搞清楚什么是面向过程,从而更深刻的理解面向对象思想的特点以及两者的区别
A:面向对象思想概述
在试想一个简单的功能时,需要程序员自己通过一步一步的算法去实现和操作。每一个步骤都是参与者,并且需要程序员自己去编写每一个步骤的代码,这就是面向过程的开发。
那么什么是面向过程开发呢? 面向过程开发,其实就是面向着具体的每一个步骤和过程,把每一个步骤和过程完成,然后由这些功能方法相互调用,完成需求。
面向过程的代表语言:C语言
B:面向对象思想
面向对象程序设计(简称OOP),每个对象都包含对用户公开的特定功能部分和隐藏的实现部分。
在OOP中,不必关心对象的具体实现,只要能够满足用户的需求即可。
并且OOP中,数据是第一位的,然后再考虑操作数据的算法。
C:面向对象思想特点
a:是一种更符合我们思想习惯的思想 懒人思想
b:可以将复杂的事情简单化
c:将我们从执行者变成了指挥者
角色发生了转换
D:面向对象的特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
类与对象的区别
A:我们学习编程是为了什么
我们学习编程语言,就是为了模拟现实世界的事物,实现信息化。比如:去超市买东西的计费系统,去银行办业务的系统。
B:我们如何描述现实世界事物
举例: 描述学生事物
姓名 , 年龄 , 性别 ....
学习 , 吃饭 , 睡觉 ....
属性: 就是该事物的描述信息
行为: 就是该事物能够做什么
我们学习编程语言,就是为了模拟现实中的事物,我们学习的Java语言最基本单位是类,所以,我们就应该把事物用一个类来体现。
由此我们就得到了现实中的事物和类的对应关系
事物 类
属性 ----------------- 成员变量
行为 ----------------- 成员方法
C:定义类其实就是定义类的成员(成员变量和成员方法)
a:成员变量 和以前定义变量是一样的,只不过位置发生了改变。在类中,方法外。
b:成员方法 和以前定义方法是一样的,只不过把static去掉,后面在详细讲解static的作用。
D:类和对象的概念
a:类:是一组相关的属性和行为的集合
b:对象:是该类事物的具体体现
c:举例:
类 学生
对象 班长就是一个对象
类的使用语法
A:文件名问题
在一个java文件中写两个类:一个基本的类,一个测试类。
建议:文件名称和测试类名称一致。
B:如何使用呢?
创建对象使用。
C:如何创建对象呢?
格式:类名 对象名 = new 类名();
D:如何使用成员变量呢?
格式:对象名.变量名
E:如何使用成员方法呢?
格式:对象名.方法名(...)
一个类可以有多个对象
利用面向对象的思想分析例子
创建person类的对象
//在主函数中创建Person对象,并调用Person类中的成员变量(属性)和成员方法(功能)
public class Mytest1{
public static void main(String[] args){
/*类名 对象名 = new 类名();
new关键字会在堆内存区开辟空间*/
Person person = new Person();
//适用对象来调用属性和功能
String name=person.name;
int age=person.age;
char sex=person.sex;
//调用类的功能 对象名.方法名()
person.eat();
person.sleep();
person.playGame();
//再创建一个person对象
Person p1 = new Person();
p1.name="李四";
p1.age=30;
p1.sex='女';
System.out.println(p1.name);
System.out.println(p1.age);
System.out.println(p1.sex);
p1.sleep();
p1.eat();
p1.playGame();
//再创建一个person对象
Person p2 = person;
System.out.println(p2.name);
System.out.println(p2.age);
System.out.println(p2.sex);
p2.sleep();
p2.eat();
p2.playGame();
}
}
//定义一个类
public class Person{
//定义成员变量:成员变量位于类中,方法外
String name="张三";
int age=23;
char sex='男';
//定义成员方法。
public void sleep(){
System.out.println("sleep");
}
public void eat(){
System.out.println("eat");
}
public void playGame(){
System.out.println("Play game");
}
}
一个对象内存图解
两个对象内存图解
三个对象内存图解
学生
public class MyTest3 {
public static void main(String[] args) {
//创建Student类的对象student,以引用Student类中的属性与功能
Student student=new Student();
//用student对象去引用Student类中的属性
String name=student.name;
int age = student.age;
String sex = student.sex;
double score = student.score;
name="李四";
System.out.println(name);
System.out.println(age);
System.out.println(sex);
System.out.println(score);
//引用功能
student.eat();
student.sleep();
student.study();
}
}
public class Student {
String name="张三";
int age;
String sex;
double score;
public void study() {
System.out.println("学习");
}
public void sleep(){
System.out.println("睡觉");
}
public void eat(){
System.out.println("吃饭");
}
}
面向对象
成员变量和局部变量的区别
A:在类中的位置不同
成员变量:在类中方法外
局部变量:在方法定义中或者方法声明上
B:在内存中的位置不同
成员变量:在堆内存
局部变量:在栈内存
C:生命周期不同
成员变量:随着对象的创建而存在,随着对象的消失而消失
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
D:初始化值不同
成员变量:有默认初始化值
局部变量:没有默认初始化值,必须定义,赋值,然后才能使用。
注意事项:: 局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则。
public class MyTest5 {
public static void main(String[] args) {
/*面向对象:成员变量和局部变量的区别
* 局部变量:定义在方法中的变量或者方法声明上的变量(形参)
* 成员变量:定义在类中,方法外的变量
*
* 成员变量和局部变量的区别:
* 1、局部变量属于方法,成员变量属于对象;
* 2、局部变量随着方法的调用而产生,随着方法的调用完毕而消失
* 3、成员变量随着对象的创建而产生,随着对象的执行完毕而消失;
* 4、局部变量没有初始化值,必须赋值才能使用;成员变量有默认值;
*5、局部变量存储在栈内存,
* 成员变量存储在堆内存(new出来的全部在堆内存,
* 并且随着程序执行完毕后不再被引用,被垃圾回收器回收);
*
* 变量访问规则:当成员变量和局部变量重名后,在访问变量时,按照就近原则
* 就近原则:先在局部范围找,如果找到这个变量,就使用;如果在局部范围没找到,就去成员范围找,如果找到就使用
* */
Phone p1 = new Phone();
System.out.println(p1.age);
p1.outPut("华为",899.9);
p1.outPut();
}
}
//我们可以在一个Java文件中,并列定义多个类。
// 但是只能在有主方法的类前面加Public,要么全部都不加权限修饰符
//建议一个类一个Java文件
class Phone{
//定义在方法外,类中的为成员变量
String brand="小米";
int age=10;
double price=799.9;
//局部变量定义在方法中
public void outPut(String brand,double price){
System.out.println(brand+"牌子的手机,一个"+price+"元。");
}
//局部范围没找到这两个变量,就会去成员范围找
public void outPut(){
System.out.println(brand+"牌子的手机,一个"+price+"元。");
}
}
方法的形参是类名的时候如何调用
A:Java中参数传递问题
形式参数
基本类型:形式参数的改变不影响实际参数
引用类型:形式参数的改变直接影响实际参数
B:方法的参数是类名
如果你看到了一个方法的形式参数是一个类 类型(引用类型),这里其实需要的是该类的对象。
匿名对象的概述和应用
A:什么是匿名对象
就是没有名字的对象
B:匿名对象应用场景
a:调用方法,仅仅只调用一次的时候。
b:匿名对象可以作为实际参数传递
C:案例演示
匿名对象应用场景
public class MyTest6 {
public static void main(String[] args) {
/*匿名对象:没有名字的对象*/
new Student().show();
//如果方法只调用一次,直接使用匿名对象调用,就很方便
//如果我们想要使用同一个对象,把方法调用多次的时候
//就不能使用匿名对象(每new一次,就会创建一个新的对象)
Student s1 = new Student();
s1.show();
s1.show();
s1.show();
System.out.println("=====匿名对象可以作为参数传递=====");
Student s2 = new Student();
test(s2,20);
}
//匿名对象可以作为参数传递
//如果看到一个方法的形参,要一个类 类型。你就传递一个该类的对象。
public static void test(Student s2,int a) {
s2.num=a;
System.out.println(s2.num);
}
}
class Student{
int num=200;
public void show(){
System.out.println("hehe");
}
}
封装的概述
A:封装的引入
通过学生案例,给年龄赋值为负数引出数据问题。
然后通过private解决这个问题。最后说其实这就是封装。
B:封装概述
是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
C:封装好处
隐藏实现细节,提供公共的访问方式
提高了代码的复用性
提高安全性。
D:封装原则
将不需要对外提供的内容都隐藏起来。
把属性隐藏,提供公共方法对其访问。
private关键字的概述和特点
A:private关键字特点
a:是一个权限修饰符
b:可以修饰成员变量和成员方法
c:被其修饰的成员只能在本类中被访问
B:案例演示
private关键字特点
public class MyTest {
public static void main(String[] args) {
//private 是一个权限 修饰符,可以修饰成员变量,和成员方法.
//被修饰的成员,只能在本类中访问,外界无法直接访问。
//权限修饰符 范围 public>protected>确省的>private
Student student = new Student();
int age = student.age;
int num = student.num;
int a = student.a;
student.show();
//类中私有的成员外界无法访问
//student.show2();
}
}
class Student{
private String name;
public int age;
protected int num;
int a;
public void show(){
System.out.println("abc");
System.out.println(age);
show2();
}
private void show2() {
System.out.println("abc");
}
}
private应用的标椎案例
A:private最常见的应用:
(1):把成员变量用private修饰
(2):提供对应的getXxx()和setXxx()方法
B:案例演示
演示使用封装来完善我们的学生类
package mytest7;
public class MyTest7 {
public static void main(String[] args) {
/*封装:隐藏对象的属性和是想细节,仅对外提供公共访问方式*/
//给成员变量设置值
Student s1 = new Student();
s1.name="张三";
s1.sex="男";
//设置年龄时,240我认为不合理
//此时我们需要对给成员变量赋值时,需要进行校验,看是否合理,
//以我们目前的这个语法 对象名.成员变量名=值 就给设置上去了
//那么我们可以屏蔽掉这种语法不要以 对象名.成员变量名=值 这种方式
//我们使用private关键字就可以屏蔽
/*当Student中的age成员变量设置成了private权限
这时就不能直接访问变量,因为private关键字将age的范围限制在了Student中
所以我们需要通过公共方法来对age进行赋值与获取*/
//s1.age=23;
s1.setAge(50);
s1.setAge(200);
System.out.println(s1.getAge());
}
}
public class Student {
//修饰之后,改成员就只能在本类中访问,外界无法直接访问
private int age;
String name;
//private是一个权限修饰符,可以修饰成员变量,成员方法
String sex;
//使用IDEA快速生成 get set 方法 alt+insert 弹出一个框
//选 getterAndseter选项 选择
//我们为了让用户能够在外界给设置成私有权限的成员变量赋值,就需要去调用方法来给其赋值
public void setAge(int nianling){
if(nianling >=0 && nianling<=100){
age=nianling;
}else{
System.out.println("输入错误");
}
}
//我们还得提供获取成员变量的方法
public int getAge(){
return age; //就近原则
}
}
this关键字的概述和应用、
A:为什么要有this
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题
B:this关键字特点
是当前类的对象引用。
简单的记,它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁
C:this的应用场景
解决局部变量隐藏成员变量
D:案例演示
this的应用场景
public class MyTest9 {
public static void main(String[] args) {
Student s1 = new Student();
System.out.println("调用者" + s1);
s1.setName(s1,"王老虎");
s1.setAge(s1,30);
String name = s1.getName();
int age = s1.getAge();
System.out.println(name);
System.out.println(age);
System.out.println("==========================");
Student student2 = new Student();
System.out.println("调用者" + student2);
student2.setName(student2, "王老虎");
student2.setAge(student2, 30);
String name2 = student2.getName();
int age2 = student2.getAge();
System.out.println(name2);
System.out.println(age2);
}
}
//当成员变量和局部变量重名了,就需要用this关键字来区分
//
class Student{
private String name;
private int age;
public void setName(Student s1,String name){
System.out.println("方法中的this 代表"+this);
//当成员变量和局部变量重名了,我们怎么区分
//我们可以使用this关键字来取分
//this 他代表本类的一个引用,你可以认为是本类的一个对象,那么哪个对象调用这个方法,这个方法中的this就代表这个对象。
this.name=name;
s1.name = name;
System.out.println("传过来的student"+s1);
System.out.println(this == s1);
}
public void setAge(Student student,int age) {
System.out.println("方法中的this 代表" + this);
this.age = age;
//student.age = age;
System.out.println("传过来的student" + student);
System.out.println(this==student);
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
标准的学生类代码及其测试
A:案例演示: 把手机类的成员用private修饰,给出getXxx()/setXxx()方法
public class MyTest {
public static void main(String[] args) {
Phone phone = new Phone();
System.out.println(phone.getBrand());
System.out.println(phone.getColor());
System.out.println(phone.getPrice());
phone.setBrand("小米");
phone.setColor("黑");
phone.setPrice(799.9);
System.out.println(phone.getBrand());
System.out.println(phone.getColor());
System.out.println(phone.getPrice());
}
}
public class Phone {
private String brand;
private String color;
private double price;
public void setBrand(String brand){
this.brand=brand;
}
public void setColor(String color){
this.color=color;
}
public void setPrice(double price){
this.price=price;
}
//使用IDEA快速生成get set方法 alt+insert弹出一个框,选择即可
public String getBrand(){return brand;}
public String getColor(){return color;}
public double getPrice(){return price;}
}
}
}
```java
public class Phone {
private String brand;
private String color;
private double price;
public void setBrand(String brand){
this.brand=brand;
}
public void setColor(String color){
this.color=color;
}
public void setPrice(double price){
this.price=price;
}
//使用IDEA快速生成get set方法 alt+insert弹出一个框,选择即可
public String getBrand(){return brand;}
public String getColor(){return color;}
public double getPrice(){return price;}
}