在上海乐字节学习Java的第十一天

最新推荐文章于 2024-05-11 15:19:02 发布

dirft_lez

最新推荐文章于 2024-05-11 15:19:02 发布

阅读量705

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/dirft_lez/article/details/109442234

版权

java 专栏收录该内容

66 篇文章 0 订阅

订阅专栏

面向对象的概念
面向过程
强调功能行为

面向对象
将功能封装进对象，强调具备了功能的对象
JAVA里面，有对象用对象，没有对象，那么就创造对象，用对象，之后还要维护各种对象之间的关系
面向对象的三大特征
封装
继承
多态

面向对象的编程思想力图使计算机语言中对事物的描述与现实世界中该事物的本来面目尽可能的一致。
类(class)和对象(object)是面向对象方法的核心概念。类是对一类事物描述，是抽象的、概念上的定义；对象是实际存在的该类事物的每个个体，因而也称实例(instance)。
万物皆对象
面向对象的特征
封装
将代码和其操作的数据捆绑在一起，防止外部对数据和代码的干扰。数据和代码以封装的形式链接起来就构成了一个对象
隐藏内部功能的具体实现，只保留和外部交流数据的接口。就好比电视机，用一个外壳把内部零部件及控制电路封装起来，只提供按钮或者遥控器接口供人使用。
继承
一个对象获得另一个对象的属性。通常一个对象可以从它的父类继承所有的通用属性。继承最大的好处是实现代码的高效重用，也更加形象的描述现实世界中对象的关系。
多态
即同一个动作作用不同的对象产生不同的具体行为。
类和对象
类是抽象的概念，仅仅是模版。比如“人”类
对象是一个你能看得到、摸得着的具体实体
“人”类都有：姓名、性别、年龄的属性，有说话的方法
张三是一个对象，他的姓名属性的值为：张三，性别属性的值为：男，年龄属性的值为：20。张三会说话
对象叫做类的实例化（Instance）
类不占内存，对象才占内存
面向对象的思想概述
类的组成：
在这里插入图片描述

在这里插入图片描述

类和对象举例
在这里插入图片描述

类的定义

`public class Animal 
    {
         public int legs;        
         public void  eat(){
             System.out.println(“Eating.”);
         }
         public void move(){
                        
           System.out.println(“Moving.”);
         }
     }`

legs是类的属性，也叫类成员变量。
eat,move是方法也叫类的成员函数。

语法格式：

[< 修饰符>] class < 类名>
{
[<属性>]
[<构造构造函数>]
[<方法>] 
｝

说明：修饰符public：类可以被任意访问
类的正文要用{ }括起来
举例：
public class Person{private int age ; //声明私有变量 age
public void setAge(int i) { //定义公有方法setAge
age = i;
}
}
语法格式：
[<修饰符>] 类型 < 属性名> [=初值] ;
说明：修饰符 private: 该属性只能由本类的方法访问。
修饰符 public: 该属性可以被本类以外的方法访问。
类型：任何基本类型，如int、boolean或任何类。
举例：

public class Person{
private int age; //声明private变量 age
public String name =“Jack”; //声明public变量 name
}

属性有时也称为：数据成员(数据)，成员变量(变量)

访问修饰符
在这里插入图片描述

成员变量 vs 局部变量
相同点：
1.遵循变量声明的格式：数据类型变量名 = 初始化值
2.都有作用域
不同点：
1.声明的位置的不同：成员变量：声明在类里，方法外
局部变量：声明在方法内，方法的形参部分，代码块内
2.成员变量的修饰符有四个：public private protected 缺省
局部变量没有修饰符，与所在的方法修饰符相同。
3.初始化值：一定会有初始化值。
成员变量:如果在声明的时候，不显式的赋值，那么不同数据类型会有不同的默认初始化值。
byte short int long ==>0 float double ==>0.0 char ==>空格 boolean >false
引用类型变量>null
局部变量：一定要显式的赋值。（局部变量没有默认初始化值）
4.二者在内存中存放的位置不同:成员变量存在于堆空间中；局部变量：栈空间中
总结：关于变量的分类：1）按照数据类型的不同：基本数据类型（8种） & 引用数据类型
2）按照声明的位置的不同：成员变量 & 局部变量
语法格式：
<修饰符> <返回类型> <方法名>([< 参数表>]) {
[< 语句>]
}
说明：修饰符：public,private,protected 等。
返回类型：return语句传递返回值。没有返回值：void。
举例：


`public class Person{
    private int age;
    public int getAge()  { return age; } 
    public void setAge(int i) {          
    age = i;  
    }
}`

对象的创建和使用
使用new+构造方法创建一个新的对象；
对象具有类中定义的属性及方法
使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）；
在这里插入图片描述

在这里插入图片描述

对象的产生

`class Person
{
    int age;
    void shout()
    {
        System.out.println(“Hello, I am “ + age);
    }
}
Person p1 = new Person();`

在这里插入图片描述

对象的创建和使用
如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。

`public class Zoo{
    public static void main(String args[]){
    Animal dog=new Animal();
    Animal fish=new Animal();
    dog.legs=4;
    fish.legs=0;
    System.out.println(dog.legs);   //4
    System.out.println(fish.legs);   //0
    fish.legs=2;
    System.out.println(dog.legs);   
    System.out.println(fish.legs);   
    }
}` 
`public class Zoo{
    public static void main(String args[]){
    Animal dog=new Animal();
    Animal fish=new Animal();
    dog.legs=4;
    fish.legs=0;
    System.out.println(dog.legs); 
    System.out.println(fish.legs);   
    fish=dog；
    System.out.println(dog.legs);   
    System.out.println(fish.legs);   
    }
}`

对象的使用
创建新的对象之后,我们就可以使用“ 对象名.对象成员 ”的格式，来访问对象的成员。

`class TestPerson
{
    public static void main(String[] args)
    {
         Person p1 = new Person();
         Person p2 =new Person();
         p1.age = 20;
         p1.shout();
         p2.shout();
    }
}`

在这里插入图片描述


`public class Car {    
String brand;//品牌
 String color;//颜色
 int  length;//车长
 int width;//车宽
 float emissions;//排量
 int  price;//价格 
public void run(){        System.out.println("小汽车，555~~");
    }
}` 
`public class CarDemo {
public static void main(String[] args) {
    Car mycar2 = new Car();
     mycar2.brand ="兰博基尼";
    mycar2.color = "黑色";
    mycar2.length=4780;
    mycar2.width=2030;
    mycar2.emissions= 6.5f;
    mycar2.price=730000;      mycar2.run();
    }
}` 
`Car mycar1 = new Car();
Car mycar2 = new Car();
     Car mycar2 = new Car();
    mycar2.brand ="兰博基尼";
    mycar2.color = "黑色";
    mycar2.length=4780;
    mycar2.width=2030;
    mycar2.emissions= 6.5f;
    mycar2.price=730000;    
    mycar2.run();`

对象的存储
在这里插入图片描述

类类型参数


`public static void main(String[] args) {
        //类类型的变量指向对象。
        CarFactory cf = new CarFactory();
        Car c1 = new Car();
        Car c2 = new Car();
        cf.show(c1);
        cf.show(c2);
}`

参数传递
基本类型传值，对象类型传地址
按值传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的一个副本。因此，如果函数修改了该参数，仅改变副本，而原始值保持不变。
按引用传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的内存地址，而不是值的副本。因此，如果函数修改了该参数，调用代码中的原始值也随之改变。

基本类型传值
… …
//定义了一个改变参数值的函数public static void changeValue(int x)
{x = x *2;}… …
//调用该函数int num = 5;
System.out.println(num);
changeValue(num);
System.out.println(num);
… …

在这里插入图片描述

对象类型传地址


`//定义一个改变对象属性的方法
public static void changeName(Person p) {
p.name = "Rose";    }
public static void main(String[] args) {
//定义一个Person对象，person是这个对象的引用
Person person = new Person();
System.out.println(person.name);
//调用changeName(Person p)方法
changeName(person);
System.out.println(person.name);
}`