java面向对象

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量76 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42513830/article/details/119183532
版权

面向对象

面向对象编程（OOP）

本质：以类的方式组织代码，以对象的组织（封装）数据

三大特性：

  • 封装
  • 继承
  • 多态
public class Demo {

    //该方法是和类一起加载的
    public static void a(){
        b();//这里是错误的 ，不能调用
        Demo demo = new Demo();
        demo.b(); //调用正确
    }
    
    //类进行实例化后，才存在
    public void b(){
        
    }
}

自动补全变量定义快捷键

现有代码：

new String()

使用 CTRL+ALT+V 快捷键之后代码会变为：

 String s = new String();

值传递与引用传递的区别

public class Demo {
    public static void main(String[] args) {
        int a = 1;
        change(a);//值传递
        System.out.println(a); //1

        Person person = new Person();
        System.out.println(person.name);//null
        change(person); //引用传递
        System.out.println(person.name);//name

    }

    //值传递
    public static void change(int a){
        a = 10;
    }

    //引用传递
    public static void change(Person person){
        //person是一个对象，指向的是实例化对象，是一个具体的人，可以改变属性
        person.name = "name";
    }
}

class Person{
    String name;
}

查看class文件：打开project structure---->选择Modules---->选择右边的Add Content Root，选择项目的out文件加入。

构造器

alt+insert 可以生成构造器

class Person{
    String name;

    public Person() {
    }

    public Person(String name) { 
        //一旦定义了有参构造器，如果使用无参构造器，必须有无参构造器
        this.name = name;
    }
}

特征：

  1. 和类名相同
  2. 没有返回值

作用：

  1. new 本质在调用构造方法
  2. 初始化对象的值

对象是类的一个具体的实例，对象是通过引用来操作的。

默认初始化：

  • 数字：0 0.0
  • char：u0000
  • boolean： false
  • 引用： null

封装

程序设计追求“高内聚，低耦合”。

高内聚：类内部的数据操作细节自己完成，不允许外部干涉

低耦合：仅暴露少量的方法给外部使用。

封装（数据的隐藏）：通常应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问。

属性私有，get/set方法

优点：

  • 提高程序的安全性，保护数据
  • 隐藏代码的实现细节
  • 统一接口
  • 系统可维护性增加了

继承

继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

Ctrl+H：查看该类的继承关系

super的使用：

//子类继承了父类，就会拥有父类的全部方法
//但是父类私有的方法不能被继承
class Student extends Person{

    private String name = "student";

    public void print(){
        System.out.println("Student");
    }

    public void test(String name){
        System.out.println(name); //name
        System.out.println(this.name);  //student
        System.out.println(super.name);  //person
    }

    public void test1(){
        print(); //Student
        this.print();  //Student
        super.print();  //Person
    }
}

class Person{
    protected String name = "person";

    public void print(){
        System.out.println("Person");
    }
}

先调用父类的构造器，再调用子类的构造器。

super();调用父类的构造器，必须放在子类构造器的第一行。只能出现在子类的方法或者构造方法中。

方法重写

重写：需要有继承关系，子类重写父类的方法

  1. 方法名必须相同

  2. 参数列表必须相同

  3. 修饰符：范围可以扩大但是不能缩小：public -->protected–>default—>private

    protected void test1(){//父类方法
        System.out.println("Person=>test()");
 }

//重写方法
@Override
public void test1(){
    System.out.println("Student=>test()");
}

  4. 抛出的异常：范围，可以被缩小，但不能扩大

代码示例：

public class Demo {
    //静态方法和非静态的方法区别很大
    //静态方法：方法的调用只和左边定义的数据类型有关
    // 非静态：重写
    public static void main(String[] args) {

        Student student = new Student();
        student.test(); //Student=>test()

        //父类的引用指向子类
        Person person = new Student();
        person.test(); //Person=>test()

        student.test1();  //Student=>test()
        person.test1(); //Student=>test()
    }
}

class Student extends Person{

    public static void test(){
        System.out.println("Student=>test()");
    }

    //重写方法
    @Override
    public void test1(){
        System.out.println("Student=>test()");
    }
}

class Person{
    public static void test(){
        System.out.println("Person=>test()");
    }

    public void test1(){
        System.out.println("Person=>test()");
    }
}

为什么重写？ 父类的功能子类不一定需要，或不一定满足！

不能重写的方法：

  1. static 方法，属于类，不属于实例
  2. final 常量
  3. private 方法

多态

public class Demo {
    //一个对象的实际类型是确定的  new Student（）  new Person（）
    public static void main(String[] args) {

        //可以指向的引用类型就不确定了，父类的引用指向子类
        //Student 能调用的方法都是自己的或者继承父类的
        Student student = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person person = new Student();
        Object object = new Student();

        //子类重写了父类的方法，执行子类的方法
        student.run(); //Student=>run()
        person.run(); //Student=>run()

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        student.eat(); //eat
        person.eat();//报错
    }
}

class Student extends Person{

    @Override
    public void run() {
        System.out.println("Student=>run()");
    }

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

class Person{
    public void run(){
        System.out.println("Person=>run()");
    }
}

多态注意事项：

  1. 多态是方法的多态，属性没有多态
  2. 父类与子类之间转换，类型转换异常 ClassCastException
  3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象

instanceof和类型转换

instanceof 的使用

public class Demo {

    public static void main(String[] args) {

        Student student = new Student();
        Person person = new Student();
        Object object = new Student();

        //判断是否左边可以转换为右边的类型
        //System.out.println(X instanceof Y);
        // 能不能编译通过，看X和Y是否有关系
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false

        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
//        System.out.println(person instanceof String);//编译报错

        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
//        System.out.println(student instanceof Teacher);//编译报错
//        System.out.println(student instanceof String);//编译报错

    }
}

class Student extends Person{}

class Person{}

class Teacher extends Person{}

类型转换

Student student = new Student();
Person person = new Student();
Object object = new Student();

//类型之间的转换
//高-->低 需要强制转换
((Student) person).go();
//低-->高 可以自动转换
Person person1 = student;

static关键字

静态方法里面不可以直接调用非静态，非静态里面可以直接调用静态方法。

//静态导入包
import static java.lang.Math.random;
public class Demo {

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

    public Demo() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Demo demo = new Demo(); //执行顺序：静态代码块-->匿名代码块-->构造方法
        //静态代码块只执行一次
        Demo demo1 = new Demo();//输出：匿名代码块-->构造方法
        
        System.out.println(random());//可直接调用方法
    }
}

类如果被final修饰了，该类就不能被继承了。

抽象类

//abstract 抽象类
public abstract class Demo {

    //约束，别人来实现
    //abstract 抽象方法，只有方法名字，没有方法的实现
    public abstract  void doSomething();

    public static void main(String[] args) {

    }
}

//抽象类的所有方法，继承了他的子类，都必须要实现他的方法
//除非继承该类的也是抽象类
public class A extends Demo{
    @Override
    public void doSomething() {

    }
}
  1. 不能new出来抽象类，只能靠子类去实现它
  2. 抽象类里面可写普通方法，抽象方法只能写在抽象类里面。
  3. 抽象类里面存在构造方法

接口

声明接口的关键字是interface。

//类 可以实现接口 implements 接口
//实现接口的类，就必须要重写接口中的方法
//可以利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(int a) {

    }

    @Override
    public void aaa() {

    }
}

public interface UserService {
    //接口中的所有定义方法都是抽象的 public abstract

    void add(String name);

    void delete(int a);
    
    //接口中的所有属性都是常量 public static final
    int AGE = 99;
}

特点：

  1. 约束
  2. 定义一些方法，让不同的人进行实现
  3. 接口不能被实例化
  4. implements可以实现多个接口
  5. 子类需要重写接口中的方法
  6. 方法都是public abstract属性
  7. 常量都是public static final属性

内部类

内部类就是在一个类的内部定义一个类，比如，A类中定义一个B类，那么B类相对于A类就是内部类，而A类相对B类就是外部类。

成员内部类
public class Demo {

    private int id=2;
    public void out(){
        System.out.println("外部类方法");
    }
    public class Inner{
        public void in(){
            System.out.println("内部类方法");
        }
        //获得外部类的私有属性
        public void getId(){
            System.out.println(id);
        }
    }

    public static void main(String[] args) {
        Demo demo = new Demo();

        //通过外部类实例化内部类
        Inner inner = demo.new Inner();
        inner.in();
    }
}
静态内部类
public class Demo {

    private int id=2;
    public void out(){
        System.out.println("外部类方法");
    }
    public static class Inner{
        //不可以访问外部类的非静态方法和变量
        public void in(){
            System.out.println("内部类方法");
        }
    }
}
局部内部类
public class Demo {
    private int id=2;
    //方法内写类
    public void out(){
        class Inner{
            public void in(){
                System.out.println("内部类方法");
            }
        }
    }
}
匿名内部类
public class Demo {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中
        new Student().go();

        new StudentService(){

            @Override
            public void eat() {
                
            }
        };
    }
}

class Student {
    public void go(){
        System.out.println("go");
    }
}

interface StudentService{
    void eat();
}
我是小仙女aaaa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE-方法、this 指向、（非）静态代码块
weixin_71394890的博客
05-26 105
JavaSE-方法、this 指向、（非）静态代码块方法定义静态方法与非静态方法方法调用方法重载形参与实参可变参数递归方法值传递与引用传递main 方法this 指向静态代码块 方法定义 修饰符 返回值类型 方法名(参数类型,参数名){ ... 方法体 ... return 返回值; } 修饰符：可选常用public / static。 返回值类型：方法可能会存在返回值。returnValueType是方法的返回值的类型。有返回至请根据返回类型进行设置（基本数据类型），无返回值则void。
JAVA常用类库的学习
qq_38960155的博客
09-16 219
1、泛型 泛型类： public class ClassName<T>{ private T data; public T getData() { return data; } public void setData(T data) { this.data = data; } } 泛型接口： public interface IntercaceName<T>{ T getData(); } 实现接口时，可以选择指定泛型类型，也可以选择不指定， 如下： 指定
[java学习笔记]-面向对象(1)
Mr.木Mu
07-24 215
面向对象编程(OOP)封装继承多态。
public class LuoxuanArray
u012402926的专栏
05-13 478
public class LuoxuanArray { 　　public static void main（String[] args）{ 　　int len=4; 　　int[][] arr=luoxuanStart（len）； 　　for（int i=0;i 　　for（int j=0;j 　　{ 　　System.out.print（+arr[i][j]+"\t"）； 　　}
Java OPP基础
m0_53488922的博客
09-10 237
//值传递 public class Demo01 { public static void main(String[] args) { int a = 10; System.out.println(a); change(a); System.out.println(a); //结果输出仍为1，可以看出Java是值传递 } public static void change(int a){ a =
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
Java面向对象
10-08
Java面向对象是编程领域中的一个核心概念，尤其对于初学者来说，理解并掌握这一概念至关重要。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它基于“对象”的理念，将数据和操作数据的方法封装...
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
java 面向对象 案例 合集
07-18
java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 ...
JAVA面向对象
12-22
面向对象三大特征4. this关键字5. 构造方法6. 标准的类结构7. 匿名对象8. 对象数组9. ArrayList类10. ArrayList常用方法 1. 类的定义 成员变量 直接定义在类中，在方法外。 成员方法 不写static关键字。 public ...
5.第四节demo4
ihan.的博客
05-26 167
package com.zzh.day1; public class demo4 { public static void main(String[] args){ //认识\s \w \d \ /* * \d=[0-9] * \D=[^0-9] * \s=[(空格)\t\n\x0B\f\r] 空白字符包括空格，tab,换行符，backspace,制表符，回车符 ...
面向对象(5)
qq_48967079的博客
07-28 164
面向对象5 1.Object类 ​ 1.概述 ​ Object类是所有类的根类 ​ 2.方法 hashcode() 返回该对象的哈希码 public class Demo1 { public static void main(String[] args) { Object object=new Object(); System.out.println(object.hashCode()); } } getClass()
Java基础
pybstudyjava的博客
03-29 185
JavaSE 1. Java 基础 1. JDK、JRE JRE JDK 含义 java 运行环境（java） java 开发工具（javac） 内容 java 核心类库 + JVM JRE + 开发工具 位置 客户端装的 开发者(程序员)装的 java -version：可以查看 JDK 的版本 配置环境变量 path：文件路径 classpath：类文件路径，规定 java JVM 在哪里去查找 class 文件，如果没有配置就在当前目录下查找，配置后就在配置后的目录下
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1203
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 494
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 794
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 270
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
Java面向对象技术入门教程
"面向对象技术讲义，适合初学者理解面向对象并辅助...这份面向对象技术讲义为初学者提供了全面的Java语言入门指导，涵盖了基本概念、历史背景、关键术语以及实际编程的初步步骤，是学习Java面向对象编程的良好起点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值