Java面向对象

小于同学*

已于 2022-06-09 01:24:05 修改

阅读量77

点赞数

文章标签： java 开发语言

于 2022-05-21 22:26:48 首次发布

本文链接：https://blog.csdn.net/yuyankang123/article/details/124850082

版权

Java面向对象

目标一

面向过程和面向对象的设计思想
Java 类
Java 类的定义
Java 对象
对象的创建和使用
构造方法
方法的重载

面向过程和面向对象

面向过程（procedure oriented programming）缩写POP
分析出解决问题所需要的步骤，然后把步骤一步一步实现。
面向过程直接关注流程。
面向对象（object oriented programming ）缩写 OOP 面向对象的编程语言
以分类的方式进行思考和解决问题。
面向对象先对整体关系作出分类，然后根据不同的类深入细节的处理。
面向对象的思想符合人类的认知习惯。
面向对象无法取代面向过程，他们是相辅相成的。面向对象关注于从宏观上把握事物之间的关系，在具体到如何实现某个细节时，仍然采用面向过程的思维方式。面向对象如果离开了面向过程，就无法实现真正的落地，成为无源之水。

Java 类

什么是类
类是一个模板，它描述一类事物的属性和行为的集合。
类是表示一个客观世界某类群体的一些基本特征抽象。
类的结构
成员变量：食物属性的描述；
方法：事物的行为；（可以做的事情）
构造方法：初始化对象；
内部类：即在类体中声明的类；
块：一段没有名称的代码块

Java 类的定义

第一步：发现类
根据不同类型的车，抽象出"类"
第二步：发现类的共有属性（成员变量）

成员变量是定义在类中，方法体之外的变量。
成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。
在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。
成员变量在创建对象的时候会从类中复制一份到对象中。成员变量可以被类中方法、构造方法和特定类的语句块访问。
成员变量的作用范围为整个类体。

 class Car{
 //成员变量的定义
 String name;
 int price;
 String color;
        
        }

第三步：发现类的方法

public  void run(){
              int a;
                  a=0;
              System.out.println(this.name+"汽车快速行驶"+a);
          }
          public  void run(int speed){
                System.out.println(this.name+"汽车以"+speed+"的速度快速行驶");
          }

          public void stop(){
              System.out.println(this.name+"汽车停止");
          }

Java 对象

对象：对象是类的一个实例，是以类为模板在内存中创建的实际存在的实例。
类= =汽车图纸，对象= =实际存在的一辆汽车,拥有类中定义的功能,可以被使用.

对象的创建和使用

对象的创建和使用
Car x1 = new Car();
Car x1:使用Car类作为类型声明一个变量x1.
new Car():使用new + Car类构造方法创建对象.
= :将右边创建的对象地址赋给左边的x1变量
使用x1变量访问对象中的成员变量和成员方法
同一类的每个对象由不同的成员变量存储空间。
同一类的每个对象共享该类的方法。

类和对象

总结类和对象
类是一类事物的抽象概念，是一个模型。
对象是由这个模型所创造的一个个具体从在的，实实在在存在的实例。
所以创建对象的过程也叫实例化对象。
现实生活中先有对象后有类，而编程时先设计类后创建对象。

变量分类

按照位置变量分为：

成员变量
成员变量是定义在类中，方法体之外的变量。
成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。成员变量在创建对象的时候会从类中复制一份到对象中。
成员变量可以被方法、构造方法和特定的语句块访问。
成员变量的作用范围为整个类体。
局部变量
在方法、构造方法或者语句块中定义的变量被称为局部变量。
局部变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。局部变量在使用前必须初始化赋值。
变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

方法分类

成员方法
成员方法是定义在类中。
语法格式：修饰符返回值类型方法名( 参数列表) {
方法体语句；
[return 返回值]
}
构造方法
用来初始化对象的方法

构造方法

构造方法名与类名相同,且没有返回值,且不需要使用void修饰。
作用:在构造方法中为创建的对象初始化赋值
在创建一个对象的时候，至少要调用一个构造方法。
每个类都有构造方法。如果没有显式地为类定义构造方法，Java将会为该类提供一个默认构造方法,但是只要在一个Java类中定义了一个构造方法后，默认的无参构造方法即失效。
一个类可以有多个构造方法。

 public  Car(){
              System.out.println("Car类无参的构造方法");
          }
          //this表示当前正在使用的对象
           public Car(String name,int price){
              System.out.println("有2个参数的构造方法");
                this.name = name;
                this.price = price;
          }
          
          public Car(String name,int price,String color){
              System.out.println("1.有3个参数的构造方法");
                      this.name = name;
                      this.price = price;
                      this.color = color;
          }
          
          public Car(String name,String color,int price){
                System.out.println("2.有3个参数的构造方法");
                this.name = name;
                this.price = price;
                this.color = color;
          }

方法的重载

方法的重载是指同一个类中具有相同的名字，但参数不同的多个方法。
参数不同（可以有三方面的不同）
数量不同
类型不同
顺序不同
调用时，会根据不同的参数表选择对应的方法。
注意：方法重载跟方法的返回值类型没有任何关系

目标二

对象与引用
this关键字
static关键字
代码块
包
访问权限修饰符

对象与引用

Java 语言中除基本类型之外的变量类型都称之为引用类型。
Java中的对象是通过引用对其操作的。

public class Car{
String name;
         int price;
         String color;
         }
         Car bm = new Car()

通常把这条语句的动作称之为创建一个对象，其实，它包含了三个动作

右边的“new Car()”，是以Car类为模板,在堆空间里创建一个Car类对象。
左边的“Car bm”创建了一个Car类型引用变量。所谓Car类的引用，就是以后可以用来指向Car 对象的对象引用。
”=”操作符使对象引用指向刚创建的那个Car对象。
我们可以把这条语句拆成两部分：
Car bm;
bm= new Car();
这样写，就比较清楚了，有两个实体：一是对象引用变量，一是对象本身。
new Car(); 这个语句在堆空间里创建了实体，尽管它们也是确确实实存在的实体，但是，我们看不见，也摸不着。
对象没有名字，也就没法直接访问它。我们需要通过对象引用来间接访问对象。
对象好比是一只很大的气球，但是我们抓不住它。引用变量是一根绳，可以用来系汽球。
Car car1; （1）创建一根绳子，一根还没有系上任何一个汽球的绳；
Car car2;（2）就又做了一根绳，还没系上汽球，
car1 = new Car();（3）给car1 系上气球；
car2 = car1 ；（4）这里，发生了复制行为。要说明的是，对象本身并没有被复制，被复制的只是对象引用。
结果是，car2也指向了car1所指向的对象。两根绳系的是同一只汽球。
Java中进行方法调用中传递参数时，参数传递有两种：值传递和引用传递
值传递：(形参数类型是基本数据类型)
方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。
引用传递：(形参数类型是引用数据类型参数)
也称为传地址。方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。
基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身。

this关键字

this关键字代表当前对象
使用this关键字引用成员变量
使用this关键字引用成员方法
在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，常常用来区分同名的成员变量和局部变量。

public class Demo{ 
private int a; 
public Demo(int a){ 
this.a = a; 
}
public int getA(){ 
return a; 
}
public void setA(int a){ 
this.a = a; 
} 
}

static 关键字

概念
static:静态的，可以用来修饰：属性，方法，代码块，内部类。
静态的特点
1.随着类的加载而加载，只有一份，类加载后就可以直接使用了，在方法区储存。
2.优先于对象存在，先加载类，而后才创建对象。
3.修饰的成员，被所有对象共享。
4.可不创建对象，直接被类调用。
static 修饰属性
是否用static修饰分为：静态属性和非静态属性（实例变量）
静态属性
静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存中只有一个。
非静态属性
我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。

public class Chinese{ 
         String name ;//姓名（非静态属性）
         String age;//年龄（非静态属性） 
         static String country;//国家（静态属性） 
         ｝

static 修饰方法
static修饰后的成员方法中只能访问静态的成员变量，因为静态方法也是随着类加载而加载，类加载后，不一定就创建了对象。
在static方法内部只能访问类的static属性,不能访问类的非static属性,static属性先加载。
但是非static方法内部可以访问static属性。

package day1;

public class SellBook {//模拟售书
    static int amount=50;
    public static void sellBook(){
        amount--;
    }

    public static void main(String[] args){//TestSellBook
        SellBook.sellBook();
        SellBook.sellBook();
        SellBook.sellBook();
        SellBook.sellBook();
        SellBook.sellBook();
        System.out.println("剩余书本数量："+SellBook.amount);

    }


}

在这里插入图片描述

代码块

概念
代码块：类似一个没有名称的方法。
分为实例代码块（非静态），静态代码块。
实例代码块
实例代码块在每次创建对象时自动执行
什么时候发生创建对象：new
静态代码块
静态代码块在类第一次被加载时自动执行，仅一次，与是否创建对象无关。

package day1;

public class Demo {
    String a="非静态";
    static String b="静态";
    {
        System.out.println("1"+a);
    }
    {
        System.out.println("2"+a);
    }
    static {
        System.out.println("1"+b);
    }
    static {
        System.out.println("2"+b);
    }
}

package day1;

public class TestDemo {
    public static void main(String[] args) {
        System.out.println(Demo.b);
        new Demo();//静态代码块先执行，实例代码块后执行；
        new Demo();
        Demo a1=new Demo();
        System.out.println(a1.a);
        
    }
}

在这里插入图片描述

类的加载执行

使用类
类名.静态变量，方法 / 创建对象 / 触发类的加载
类中元素的加载顺序
先加载静态的，按照从上向下的顺序执行
1.成员变量
2.实例代码块
3.构造方法
4.成员方法

package day1;

public class People {


        String name;//大家都不一样 非静态 属于对象
        static  String hand = "手";//大家都一样 static修饰

        public People(){
            System.out.println("无参构造方法");
        }

        {
            System.out.println("实例代码块");
        }
        static {
            System.out.println("静态代码块");
        }

        public void eat(){
            System.out.println(name+"睡觉"+hand);
        }

        public static void show(){
            System.out.println(hand);
        }

}

package day1;

public class TestPeople {
    public static void main(String[] args) {
        People a1=new People();
        a1.name="刘三";
        System.out.println(People.hand);
        a1.eat();
        People.show();


    }

}

在这里插入图片描述

包

概念
包：用来管理类，用于为类当作命名空间（地址）
Book,Car…这些都称为类的简称
全类名= 包名+类的简称
作用
1.避免类重名
2.按照不同的功能管理类
day1,day2 公共的功能，数据交互的功能，与前端交互的功能
3.控制访问权限
包的命名规范
包名一般情况下都是小写。在包名中，可以使用.号来区分包的级别。
1.第一级指该项目的类型，例：com,org,gov等
2.第二级指项目所开发或者运行的公司名称，如：oracle,sun,huawei 等
3.第三级指项目的名称，如：bcms,oa,erp,cms等
4.第四级指项目模块的名称，如：bean,action,exception等
关键字 import
用来导入其他包中的类，同包中使用不需要导入
在java中java.lang包中的不需要导入，可以直接使用

访问权限修饰符

访问权限修饰符
public
protected
(default)
private
public
公共权限修饰类，属性，方法 / 在任何位置都可以访问
protected
受保护的修饰属性，方法 / 在本类，同包的其他类，在不同的子类中访问
（空）
默认修饰类，属性，方法 / 在本类中，同包的其他类
private
私有的修饰属性，方法 / 只能在本类类中访问
这四种访问权限修饰符也都可以修饰内部类

package com.xytx.bao.b2;

import com.xytx.bao.b1.Package2;

public class Fwqx1 {
    public String a="公共的";
    protected String b="受保护的";
    String c="空修饰符";
    private String d="私有的";

    public void test1(){
        System.out.println(a);
    }
    protected void test2(){
        System.out.println(b);
    }
    void test3(){
        System.out.println(c);
    }
    private void test4(){
        System.out.println(d);
    }

    public static void main(String[] args) {
        Fwqx1 s1=new Fwqx1();
        s1.test4();

    }



}

在这里插入图片描述

package com.xytx.bao.b2;

import com.xytx.bao.b1.Package2;

public class Fwqx2 extends Package2 {
    public static void main(String[] args) {
        Fwqx1 f1 = new Fwqx1();
        f1.test1();
        f1.test2();
        f1.test3();

    }
}

在这里插入图片描述

目标三

面向对象特征
面向对象特征–封装
面向对象特征–继承
抽象类
面向对象特征–多态
final 关键字
接口

面向对象特征

面向对象语言的三大特征
1.封装
2.继承
3.多态

面向对象特征–封装

封装广义
多次验证账号密码是否正确，抽取一个check().封装（包装）
面向对象语言中的封装
是对类中的信息进行隐藏（访问权限），不让外部知道类中有哪些信息（成员变量，方法）。
封装的好处
1.只能通过规定方法访问
2.隐藏类的实现细节
3.方便加入控制语句
4.方便修改实现

package day1;

public class Person {
//属性的私有化，是封装的一种体现，提供外界能够访问到的方法
    private   String name;
    private   int age;

    public void setName(String name){
        if(name.length()>=2&&name.length()<6){
            this.name  = name;
        }
    }
    public String getName(){
        return this.name;
    }

    public  void setAge(int age){
        this.age = age;
    }
    public int  getAge(){
        return age;
    }

}

package day1;

public class TestPerson {
    public static void main(String[] args) {
        Person zs = new Person();
        // zs.name = "jimto";
        zs.setName("张三");
        System.out.println(zs.getName());
        zs.setAge(20);
        System.out.println(zs.getAge());


    }
}

在这里插入图片描述

设计模式
前人总结出的解决某类问题的最有效方案——模板
单例模式
需要某个类在整个应用程序中，只能创建一个对象。

package day3;
//懒汉单例
public class Add {
    static Add sum = null;
    //将构造方法私有化，在程序的其他地方就不能随意地调用构造方法
    private Add(){

    }
    //向外界提供一个方法，用来获得创建的唯一的对象，在类内部控制起来就比较方便
    public static Add getAdd(){
        if(sum == null){
            sum = new Add();
        }
        return sum;
    }

}

package day3;
//饿汉单例（急切式单例）
public class Add1{
    //在类加载的时候，就直接将对象创建，由于静态，只加载一次
    static Add1 sum = new Add1();
    //将构造方法私有化，在程序的其他地方就不能随意地调用构造方法
    private Add1(){

    }
    //向外界提供一个方法，用来获得创建的唯一的对象，在类内部控制起来就比较方便
    public static Add1 getAdd(){
        return sum;
    }

}

package day3;

public class TestAdd {
    public static void main(String[] args) {
    /*
    new Add();不能直接创建对象
    */
        Add a1 = Add.getAdd();
        Add a2 = Add.getAdd();
        Add a3 = Add.getAdd();
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
        Add1 a3 = Add1.getAdd();
        Add1 a4 = Add1.getAdd();
        Add1 a5 = Add1.getAdd();
        System.out.println(a3);
        System.out.println(a4);
        System.out.println(a5);

    }


}

在这里插入图片描述

面向对象特征–继承

概念
子类继承父类。使用父类中已经实现好的功能，而且子类还可以扩展自己特有的功能。
面向对象设计宗旨
代码复用性高，代码扩展强
什么情况下用继承
1.满足什么是什么 is - a 关系（继承）玫瑰是花，向日葵是花
2.将子类共有的熟悉和行为放到父类中
3.具体的语法——使用extends

小于同学*

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象

文章目录Java面向对象目标面向过程和面向对象Java面向对象目标面向过程和面向对象的设计思想Java 类Java 类的定义Java 对象对象的创建和使用构造方法方法的重载面向过程和面向对象面向过程（procedure oriented programming）缩写POP分析出解决问题所需要的步骤，然后把步骤一步一步实现。面向过程直接关注流程。面向对象（object oriented programming ）缩写 OOP 面向对象的编程语言以分类的方式进行思
复制链接

扫一扫