Java面向对象基础

最新推荐文章于 2024-04-04 15:16:07 发布
最新推荐文章于 2024-04-04 15:16:07 发布
阅读量509 收藏
点赞数 1
分类专栏： Java Java 入门 文章标签： 从零开始的Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NightCharm/article/details/90050731
版权

文章目录

JAVA 基础 面向对象

什么是成员变量、局部变量、静态变量

成员变量

  • 成员变量 定义在类中， 在整个类中都可以被访问到
  • 成员变量随着对象的建立而建立， 随着对象的消失而消失
  • 成员变量有默认初始化值
示例
class Car{
    private String name;  // 成员变量
    private String color;  // 成员变量
}

局部变量

  • 局部变量只定义在局部范围内， 如：函数、 语句内 ， 只在所属的区域有效
  • 局部变量存在于栈内存中， 作用的范围结束， 变量空间会自动释放
  • 局部变量没有默认初始化值
示例
class Car{
    public void main(String[] args){
        Integer sum = 0;  // 局部变量
        for (int i = 0; i < 10; i++) {  // 这里的i 也是局部变量
            sum += i;
        }
        System.out.println(sum);
    }
}

静态变量

  • 由static 修饰的变量成为静态变量， 其 实质上就是一个全局变量。 如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰； 没有被静态修饰的内容，其实就是对象的特殊描述。
示例
class Person{
    // 成员变量， 实例变量
    String name;
    
    // 静态变量， 类变量
    static String COUNTRY = "CN";
}

成员变量和静态变量的区别

  1. 两个变量的生命周期不同
    • 成员变量随着对象的创建而存在，随着对象的回收而释放
    • 静态变量随着类的加载而存在， 随着类的消失而消失
  2. 调用方式不同
    • 成员变量只能被对象调用
    • 静态变量可以被对象调用，还可以被类名调用
  3. 别名不同
    • 成员变量也称为 实例变量
    • 静态变量也称为 类变量
  4. 数据存储位置不同
    • 成员变量存储在堆内存的对象中，也叫做对象的特有数据
    • 静态变量存储在方法区（共享数据区）的静态区， 所以也叫做对象的共享数据

##访问修饰符

一句话 private 和 public

private 仅可以在 类内部使用
public 可以在任意地方使用

构造方法

当new 一个对象的时候 其实就是在调用构造方法，当没有定义构造方法的时候， Java 会默认提供一个无参的构造方法

例如

class Student{
    // 这时就会默认提供一个无参的构造方法
    /*
    	public Student(){} // 构造方法的名字必须和类名相同， 并且不需要提供返回值
    */
}

通过构造方法初始化参数

class Student{
    private String name;
    private Integer age;
    
    public Student(){}
    
    public Student(String name){
        this.name = name;
    }
    
    public Student(String name, Integer age){
        this.name = name;
        this.age = age;
    }
    
    public static void main(String[] args){
        new Student("CharmNight", 21);
        new Student("CharmNight");
        new Student();
    }
}

通过上面的方法也可以看出 构造方法 可以有多个

this 关键字

this 关键字只能在类中使用， 代表当前对象。

示例一： 通过this区分成员变量 用于赋值

class Student{
    private String name;
    private Integer age;
    
    public Student(String name){
        // 这里就是使用 this 区分成员变量和参数
        // this. 来访问成员变量 直接访问的是参数
        this.name = name;
    }
}

示例二： 通过this访问成员方法

class Student{
	private String name;
	
	private void cheat(){
		System.out.println("考试作弊");
	}
	public void examination(){
		this.cheat();
	}
}

静态

static关键字

含义

​ Java中不存在真正意义上的全局变量，但是可以通过static来实现一个“伪全局”的概念，在Java中static表示全局 或者 静态的意思， 用来修饰成员变量和成员方法， 也可以修饰代码块.

​ Java把内存分为堆内存和栈内存，其中栈内存用来存放一些基本类型的变量、数组和对象的引用。

堆内存主要存放一些对象。JVM加载一个类的时候，若该类存在static修饰的成员变量和成员方法，则会为这些成员变量和方法 在固定的位置开辟一个固定大小的内存区域.

​ 同时被static修饰的成员变量和成员方法是独立该类的，它不依赖于某个特定的实例变量，也就是说它被该类的所有实例共享。所有实例的引用都指向同一个地方，任何一个实例对其进行修改都会导致其他实例的变化。

例子

public class Person {
    public static String country;// 静态变量
    private String name;
    private int age;
    Person(String name, int age){
        this.age = age;
        this.name = name;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public static void show(){
        // 静态方法中 只能调用 静态的 方法 or 变量
        // 且 不能使用 this super 关键字
        System.out.println(country);
    }
}


class PersonTest{
    public static void main(String[] args) {

        Person p1 = new Person("siki", 10);
        p1.country = "CN"; // 一般使用 Person.country = "CN"
        Person p2 = new Person("Peter", 20);
        p2.country = "US"; // Person.country = "US"

        System.out.println(p1.getName() + p1.getAge() + p1.country);
        System.out.println(p2.getName() + p2.getAge() + p2.country);
    }
}

------输出结果-----
siki10US
Peter20US

static占内存

static 修饰的变量 会在 类加载时在 方法区（共享）的静态区中开辟一块内存进行存储

static 是和类进行绑定的

###static特点

  • 随着类的加载而加载
  • 优先于对象存在
  • 所有对象共享（可以通过对象或类来访问）
局限性
  • 只能调用static变量和 static 方法
  • 不能以任何形式引用 this、`super
总结

无论是变量，方法，还是代码块，只要被static修饰，就在类被加载的时候被创建

静态代码块

static{
    // 这里就是静态代码块 在加载类时 仅执行一次
}
示例
public class StaticDemo {
    static float pi;
    static {
        pi = 3.14F;
        System.out.println("静态代码块执行");
    }

    StaticDemo(){
        System.out.println("构造函数执行");
    }

    public static void main(String[] args) {
        new StaticDemo();
        new StaticDemo();
    }

}

------打印结果-------
静态代码块执行
构造函数执行
构造函数执行

封装

数据私有化 private ，但不止这一个状态 应该说除了public 都是封装的思想，

除了private 类、 方法 这些都属于封装的思想

优点

  • 良好的封装能减少耦合
  • 类内部的结构可以自由的改变
  • 可以对成员进行更精确的控制
  • 隐藏信息，实现细节
更精确的控制成员

防止 属性被随意修改

class Student{
    public String name;
    
    public Student(){
        this.name = "CharmNight";
    }
}

class StudentTest{
    public void main(String[] args){
        Student st = new Student();
        // xxx 一顿操作
        st.name = "hh"; //？？ 误修改
    }
}
GET SET 方法
class Student{
    private String name;
    
    public void setName(String name){
        this.name = name;
    }
    
    public String getName(){
        return this.name;
    }
}

class StudentTest{
    public void main(String[] args){
        Student st = new Student();
        // 通过 get set 方法 来 获取 修改 私有变量
        st.setName("CharmNight");
        st.getName();
    }
}
隐藏信息，实现细节
class Phone{
    private String cpu;
    private String color;
    private Boolean power;
    
    public Phone(){
        this.power = false;
    }
    
    private void phoneInnerShutDown(){
        // 手机内部关机逻辑
        this.color = "black";
        this.cpu = "down";
        this.power = false;
    }
    
    private void phoneInnerBoot(){
        // 手机内部开机逻辑
        this.color ="color";
        this.cpu = "on";
        this.power = true;
    }
    
    public void run(){
        // 傻瓜式 按电源开机 or 关机
        if(this.power){
	        this.phoneInnerShutDown();        
        }else{
            this.phoneInnerBoot();
        }
    }
}

class phoneTest{
    public static void main(String[] args){
        Phone phone = new Phone();
        phone.run(); // 开机了 可以愉快的玩耍了
    }
}
良好的封装能减少耦合
类内部的结构可以自由的改变

内部类


class Outer{
    private int age;
    public Outer(int age){
        this.age = age;
    }

    private class Inner{
        private String name;
        public Inner(String name){
            this.name = name;
        }
        public void show(){
            System.out.println(this.name);
        }
    }

    public void test(){
        Inner inner = new Inner("innerClass");
        inner.show();
    }

    public static void main(String[] args) {
        Outer outer = new Outer(12);
        outer.test();
    }
}

注意事项

  • 内部类不能声明static
  • 内部类可以访问外部类的成员变量， 外部类不可访问内部类的成员变量

继承

概念

  • 继承就是子类继承父类的行为。
  • 继承是一种代码复用。
  • 继承 所描述的是 “is-a” 的关系 ， 如果有两个对象A和B, 若可以描述为 A是B 则可以表示A继承B，其中B是被继承者 被称之为父类 或者 超类，A是继承者 称之为子类或者派生类
注意

  1. 子类拥有父类非private 的属性和方法

  2. 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展

  3. 子类可以用自己的方式实现父类的方法

  4. 子类和父类梨有同名变量，就近原则（this super）

    可以通过super 访问父类梨的变量、方法和构造方法

例子

public class Person {
    private String name;
    private int age;

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

}

public class Student extends Person {
    private String className;

    public Student(String name, int age, String className) {
        super(name, age);
        this.className = className;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
｝

优点

  • 减少了代码量
  • 代码更容易维护

Java不支持多继承

重载

类名相同，但参数不同，返回值可以相同也可以不同

规则
  • 被重载的方法必须改变参数列表(参数个数或类型不一样)；
  • 被重载的方法可以改变返回类型；
  • 被重载的方法可以改变访问修饰符；
  • 被重载的方法可以声明新的或更广的检查异常；
  • 方法能够在同一个类中或者在一个子类中被重载。
  • 无法以返回值类型作为重载函数的区分标准。

重写

子类中的方法名、参数和返回值与父类相同

意义

子类跟父类拥有同样的功能，但是子类有自己的特定内容和特定实现方式。可以定义一个不同的名字方法，但是为了见名知意，保持父类的名字，自己重新实现方法体

注意事项
  • 不能重写private方法
  • 不能重写final的方法
  • 不能重写static方法 但可以再次声明
  • 重写的时候，访问权限不能变更

多态

定义

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作

允许不同类的对象对同一消息作出响应

作用

消除类型之间的耦合关系

实现方式

  • 重写
  • 接口
  • 抽象类抽象方法
class Person{
    
}

class Student extend Person{
    
}

class Test{
    public static void main(String[] args){
        Person p = new Student(); // 多态
    }
}

抽象

抽象类

定义

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

例子

abstract class Person{
    private String name;

    public Person(String name){
        this.name = name;
    }

    public abstract void eat();

    public void run(){
        System.out.println("跑路");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Student extends Person{

    public Student(String name) {
        super(name);
    }

    public void eat() {
        System.out.println("吃");
    }
}

public class absDemo {
    public static void main(String[] args) {
        Person p = new Student("Night");
        System.out.println(p.getName());
        p.eat();
        p.run();
    }
}

接口

定义

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类相似点：

  • 一个接口可以有多个方法。
  • 接口文件保存在 .java 结尾的文件中，文件名使用接口名。
  • 接口的字节码文件保存在 .class 结尾的文件中。
  • 接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

  • 接口不能用于实例化对象。
  • 接口没有构造方法。
  • 接口中所有的方法必须是抽象方法。
  • 接口不能包含成员变量，除了 static 和 final 变量。
  • 接口不是被类继承了，而是要被类实现。
  • 接口支持多继承。

接口特性

  • 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
  • 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
  • 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别

  1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

  2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

  3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

  4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

例子

public interface USB{
    public Integer USB3();
}
NightCharm
关注
专栏目录
JAVA面向对象基础ppt课件.ppt
11-13
"JAVA面向对象基础ppt课件" 本课件主要介绍了Java面向对象编程的基础知识，包括类和对象的关系、面向对象的思想、构造方法、对象创建的内存模型、垃圾回收机制、Java中的关键字等。 一、类和对象的关系 在面向...
java基础03-面向对象
quzhiyuan9的博客
07-20 769
面向过程（Procedural Programming）和面向对象（Object-Oriented Programming，简称 OOP）是两种不同的编程范式。面向对象是一种以对象为中心的编程思想。它将程序视为对象的集合，每个对象都有自己的状态（属性）和行为（方法）。在面向对象编程中，数据和操作是紧密相关的，并通过封装、继承和多态等机制实现代码的组织和复用。主要特点包括：1.以对象为核心：程序由多个相互交互的对象组成，每个对象都有自己的属性和方法。
Java面向对象编程基础知识
shixiaowei00的博客
02-14 1111
面向对象编程的本质是:以类的方式组装代码,以对象的组织(封装)数据。抽象:三大特征:封装 继承 多态从认知角度考虑:是先有对象再有类。对象是一个具体的东西。类是抽象的,类是由一个一个的对象的相同特征抽象出来的。从代码角度考虑:是先有类才有对象。类是对象的模板。//类是用class修饰的,这个类的名字是Application//main方法 用来启动当前程序/*定义一个方法的格式:修饰符 返回值 方法名(形式参数)方法体:代码主要在方法体执行返回值*/
java——面向对象基础
Wooo_e的博客
02-28 1716
是一种具体步骤的操作，他是微观的。适合解决简单问题，先分析出解决问题的步 骤，然后一步一步的（用函数）去实现即可。c语言就是一个典型的面向过程的语言。结构简单，修改复杂。（程序设计越来越复杂，单纯的面向过程就难以胜任设计程序的需求，现在大多数的语言都是面向对象，c++,C#,java,python....面向对象：是指宏观上分析程序有哪些功能，然后对功能进行分类，把不同的功能封装在不同的类中。他是一种宏观的设计。代码结构：以类为组织单位。每种事物都具备自己的属性和行为/功能。类：具有。
Java 面向对象（基础）
最新发布
m0_63272315的博客
04-04 1150
1. 面向对象内容的三条主线：- Java类及类的成员：（重点）属性、方法、构造器；（熟悉）代码块、内部类- 面向对象的特征：封装、继承、多态、（抽象）- 其他关键字的使用：this、super、package、import、static、final、interface、abstract等2. 面向过程编程(POP) vs 面向对象编程(OOP)2.1 简单的语言描述二者的区别> 面向过程：- 以`函数`为组织单位。- 是一种“`执行者思维`”，适合解决简单问题。
java面向对象基础知识点.doc
03-10
Java 面向对象基础知识点 Java 是一门面向对象的编程语言，面向对象编程（Object-Oriented Programming，OOP）是 Java 语言的核心。了解 Java 面向对象的基础知识是掌握 Java 语言的关键，本文将对 Java 面向对象的...
JAVA面向对象基础
11-12
### JAVA面向对象基础知识点详解 #### 一、面向对象编程语言的发展史 面向对象编程（Object-Oriented Programming，简称OOP）是一种重要的编程范式，其核心在于将现实世界中的对象及其属性和行为映射到软件系统中...
JAVA面向对象基础学习资料
07-09
JAVA面向对象的基础学习资料，包括了以下学习内容和代码注释： 01_成员变量和局部变量的区别 02_形式参数是类名的问题 03_匿名对象 04_封装和private关键字 05_this关键字 06_构造方法 07_成员方法 08_创建对象做了...
java面向对象基础
11-07
Java面向对象基础是Java编程的核心概念，它基于“万物皆对象”的哲学思想，使得程序设计更加贴近现实世界的问题解决方式。在这个主题中，我们将深入探讨类、对象、封装、继承和多态等核心概念。 首先，类是面向对象...
Java面向对象基础知识点复习
11-08
1.面向对象的三个特征  封装：封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。  继承：继承实际上是存在与...
java面向对象基础保姆级教程
02-20
java面向对象基础保姆级教程
6-Java面向对象基础(01)
04-30
Java是一种广泛使用的面向对象编程语言，其设计哲学是“一切皆为对象”。在Java中，面向对象编程（Object-Oriented Programming，OOP）是一种重要的编程范式，它与面向过程编程有所不同。本节我们将深入探讨这两者的...
java面向对象编程pdf
04-16
在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为。 一、对象和类 在...
JAVA基础篇——面向对象基础
qq_44689664的博客
12-09 480
面向对象编程基础、计算机执行原理、this关键字、构造器、封装、实体类
Java学习——面向对象基础
qq_45944185的博客
02-25 250
java面向对象基础知识，包括两大功能三大特征，修饰符与关键字的解读
java面向对象基础知识总结
大前端开发工程师、互联网方向创业者
01-14 602
整理了Java面向对象编程的基础知识
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值