Java面向对象

于 2024-03-10 08:04:08 发布
阅读量1.6k 收藏 46
点赞数 34
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73557953/article/details/136595231
版权

Day1 面向对象基础

this

当局部变量和全局变量的数据类型和名称都相同时，Java规定可以使用this关键字去访问全局变量

this语法格式：

this.成员变量名

this.成员方法名()

this就是一个变量，可以用在方法中，来拿到当前对象

用于解决变量名称冲突问题

package com.itheima.object.thisdemo;
​
public class Student {
    double score;
​
    public void printThis(){
        System.out.println(this);
    }
​
    public void printPass(double score){
        if(this.score > score){
            System.out.println("恭喜您，您成功考入了东北林业大学");
        }else{
            System.out.println("落选了");
        }
    }
}
​
​
package com.itheima.object.thisdemo;
​
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(s1);
        s1.printThis();
​
        Student s2 = new Student();
        System.out.println(s2);
        s2.printThis();
​
        Student s3 = new Student();
        s3.score = 365;
        s3.printPass(280);
    }
​
​
}
​
构造器
无参构造器
public Student(){
        
}
有参构造器
public Student(String name,double score){
    
}

特点：创建对象时，对象会去调用构造器

Student s = new Student();

package com.itheima.constructor;
​
public class Student {
    String name;
    double score;
    //无参数构造器
    public Student(){
        System.out.println("无参数构造器被触发执行了");
    }
    //有参数构造器
    public Student(String name,double score){
        System.out.println("有参数构造器被触发执行了");
        this.name=name;
        this.score=score;
    }
}
​
package com.itheima.constructor;
​
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student("波仔",99);
        System.out.println(s2.name);
        System.out.println(s2.score);
    }
}
​

类在设计时，如果不写构造器，Java会为类自动生成一个无参构造器

一旦定义了有参构造器，Java就不会帮我们的类自动生成无参构造器了，此时就建议自己手写一个无参数构造器出来

面向对象三大特征：封装、继承、多态

封装

封装的设计规范

成员变量隐藏起来，设置合适的get、set方法暴露给外界访问

实体类

  1. 要求这个类中的成员变量都要私有，并且要对外提供相应的get、set方法

  2. 类中必须要有一个公共的无参构造器

package com.itheima.javabean;
​
public class Student {
    //1.实体类必须私有成员变量，并为每个成员变量提供get set方法
    private String name;
    private double score;
    
    //2.必须为类提供公开的无参构造器
    public Student(String name, double score) {
        this.name = name;
        this.score = score;
    }
​
    public Student() {
    }
​
  
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public double getScore() {
        return score;
    }
​
    public void setScore(double score) {
        this.score = score;
    }
​
}
​
自动生成get、set方法

按住shift键全选

自动生成无参构造器

自动生成有参构造器

包

  1. 同一个包下的程序，可以直接访问

  2. 访问其他剥下的程序，必须导包才可以访问

  3. 自己的程序中调用Java提供的程序，也需要先导包才可以使用；注意：Java.lang包下的程序是不需要我们导包的，可以直接使用

  4. 访问多个其他包下的程序，这些程序名又一样的情况下，默认只能导入一个程序，另一个程序必须带包名和类名来访问

String

package com.itheima.String;
​
public class StringDemo1 {
    public static void main(String[] args) {
        String s = "黑马Java";
        //1.获取字符串的长度
        System.out.println(s.length());
        //2.提取字符串中某个索引位置处的字符
        char c = s.charAt(1);
        System.out.println(c);
        //3.把字符串转换成字符数组，再进行遍历
        char[] chars = s.toCharArray();
        for(int i = 0;i < chars.length; i++){
            System.out.println(chars[i]);
        }
        //4.判断字符串内容，内容一样就返回true
        String s1 = new String("黑马");
        String s2 = new String("黑马");
        System.out.println(s1==s2);//false  判断的是地址
        System.out.println(s1.equals(s2));//true
        //5.忽略大小写比较字符串内容，常用于验证码
        String c1 = "34AeFG";
        String c2 = "34aEfg";
        System.out.println(c1.equals(c2));//false
        System.out.println(c1.equalsIgnoreCase(c2));//true
        //6.截取字符串内容(包前不包后)
        String s3 = "Java是最好的编程语言之一";
        String rs = s3.substring(0,8);
        System.out.println(rs);
        //7.从当前索引位置一直截取到字符串末尾
        String rs2 = s3.substring(5);
        System.out.println(rs2);
        //8.把字符串中的某个内容替换成新内容，并返回新的字符串对象给我们--用于替换敏感词
        String info = "这个电影简直是个垃圾";
        String rs3 = info.replace("垃圾","**");
        System.out.println(rs3);
        //9.判断字符串中是否包含某个关键字
        String info2 = "Java是最好的编程语言之一";
        System.out.println(info2.contains("Java"));//true
        //10.判断字符串是否以某个字符串开头
        String rs4 = "张三丰";
        System.out.println(rs4.startsWith("张"));//true
        System.out.println(rs4.startsWith("张三"));//true
        //11.把字符串按照某个指定内容分割成多个字符串，放到一个字符串数组中返回给我们
        String rs5 = "张无忌，周芷若，殷素素，赵敏";
        String[] names = rs5.split(",");
        for(int i = 0 ;i  <names.length;i++){
            System.out.println(names[i]);
        }
    }
}
String案例 —— 用户登录

package com.itheima.String;
​
import java.util.Scanner;
​
public class StringTest {
    public static void main(String[] args) {
        for(int i=0;i<3;i++) {
            //1.开发一个登录界面
            Scanner sc = new Scanner(System.in);
            System.out.println("请您输入登录名称：");
            String loginName = sc.next();
​
            System.out.println("请您输入登录密码：");
            String passWord = sc.next();
​
            //5.开始调用登录方法，判断是否登陆成功
            boolean rs = login(loginName, passWord);
            if (rs) {
                System.out.println("恭喜您，欢迎进入系统~~");
                break;
            } else {
                System.out.println("登录名或者密码错误，请您确认~~");
            }
        }
    }
​
    //2.开发一个登录方法，接收用户的登录名和密码，返回认证的结果
    public static boolean login(String loginName,String passWord){
        //3.准备一份系统正确的登录名和密码
        String okLoginName = "itheima";
        String okPassWord = "123456";
​
        //4.开始正式判断用户是否登录成功
        if(okLoginName.equals(loginName)&&okPassWord.equals(passWord)){
            return true;
        }else{
            return false;
        }
    }
}
​
String案例 —— 验证码

package com.itheima.String;
​
import java.util.Random;
​
public class StringTest2 {
    public static void main(String[] args) {
        System.out.println(createCode(4));
    }
​
    //1.设计一个方法，返回指定位数的验证码
    public static String createCode(int n){
        //2.定义2个变量 一个是记住最终产生的随机验证码；一个是记住可能用到的全部字符
        String code ="";
        String data="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
​
        Random r = new Random();
        //3.开始定义一个循环产生每位随机字符
        for(int i = 0;i<n;i++){
            //4.随机一个字符范围内的索引
            int index = r.nextInt(data.length());
            //5.根据索引去全部字符中提取该字符
            code += data.charAt(index);
        }
        return code;
    }
}
ArrayList

什么是集合：一种容器，用来存储数据

集合显著特点：集合大小可变

package com.itheima.arraylist;
​
import java.util.ArrayList;
​
public class ArrayListDemo {
    public static void main(String[] args) {
        //1.创建一个ArrayList的集合对象
        ArrayList list = new ArrayList();
        list.add("黑马");
        list.add(666);
        list.add(99.5);
        list.add("黑马");
        list.add("Java");
        System.out.println(list);
​
        ArrayList<String>list2 = new ArrayList<String>();
        list2.add("黑马");
        list2.add("黑马");
        list2.add("Java");
        System.out.println(list2);
​
        //2.往集合中某个索引位置处添加一个数据
        list.add(1,"MySQL");
        System.out.println(list);
​
        //3.根据索引获取集合中某个索引位置处的值
        String rs = list2.get(1);
        System.out.println(rs);
​
        //4.获取集合的大小（返回集合中存储的元素个数
        System.out.println(list2.size());
​
        //5.根据索引删除集合中的某个元素值，会返回被删除的元素值给我们
        System.out.println(list.remove(1));
        System.out.println(list);
​
        //6.直接删除某个元素值，删除成功会返回true，反之
        System.out.println(list.remove("Java"));
        System.out.println(list);
        //默认删除的是第一次出现的黑马数据
        System.out.println(list.remove("黑马"));
        System.out.println(list);
​
        //7.修改某个索引位置处的数据，修改后会返回原来的值给我们
        System.out.println(list.set(1,"黑马程序员"));
        System.out.println(list);
    }
}
​
ArrayList应用案例

package com.itheima.arraylist;
​
import java.util.ArrayList;
​
public class ArrayListTest {
    public static void main(String[] args) {
        //1.创建一个ArrayList集合对象
        ArrayList<String> list = new ArrayList<String>();
        list.add("Java入门");
        list.add("宁夏枸杞");
        list.add("黑枸杞");
        list.add("人字拖");
        list.add("特级枸杞");
        list.add("枸杞子");
        System.out.println(list);
​
        //[Java入门, 宁夏枸杞, 黑枸杞, 人字拖, 特级枸杞, 枸杞子]
        //[Java入门, 黑枸杞, 人字拖,  枸杞子]
        //2.开始完成需求：从集合中找出包含枸杞的数据并删除它
        /*
        for(int i=0;i<list.size();i++){
            //1 = 0 1 2 3 4 5
            //取出当前遍历到的数据
            String ele = list.get(i);
            //判断这个数据中包含枸杞
            if(ele.contains("枸杞")){
                //直接从集合中删除该数据
                list.remove(ele);
            }
        }
        System.out.println(list);
        */
​
        //方式一：每次删除一个数据后，就让i往左退一步
        /*
        for(int i=0;i<list.size();i++){
            //1 = 0 1 2 3 4 5
            //取出当前遍历到的数据
            String ele = list.get(i);
            //判断这个数据中包含枸杞
            if(ele.contains("枸杞")){
                //直接从集合中删除该数据
                list.remove(ele);
                i--;
            }
        }
        System.out.println(list);
        */
        //方式二：从集合的后面倒着遍历并删除
        //[Java入门, 宁夏枸杞, 黑枸杞, 人字拖, 特级枸杞, 枸杞子]
        //                                           i
        for(int i=list.size()-1;i>=0;i--){
            //取出当前遍历到的数据
            String ele = list.get(i);
            //判断这个数据中包含枸杞
            if(ele.contains("枸杞")){
                //直接从集合中删除该数据
                list.remove(ele);
            }
        }
        System.out.println(list);
    }
}
​
ArrayList综合案例

package com.itheima.arraylist;
​
public class ArrayListTest2 {
    public static void main(String[] args) {
        //完成案例：商家菜品上架工作
        //1.要设计菜品对象首先应该设计菜品类；设计菜品类Food负责创建菜品对象，封装菜品数据
        //2.设计一个菜品操作类FoodOperator,负责完成对菜品的业务实现：上架，浏览信息
        FoodOperator operator = new FoodOperator();
        operator.start();
​
    }
}
​
package com.itheima.arraylist;
​
public class Food {
    private String name;
    private double price;
    private String desc;//描述
​
    public Food() {
    }
​
    public Food(String name, double price, String desc) {
        this.name = name;
        this.price = price;
        this.desc = desc;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public double getPrice() {
        return price;
    }
​
    public void setPrice(double price) {
        this.price = price;
    }
​
    public String getDesc() {
        return desc;
    }
​
    public void setDesc(String desc) {
        this.desc = desc;
    }
}
​
package com.itheima.arraylist;
​
import java.util.ArrayList;
import java.util.Scanner;
​
//菜品操作类：负责上架和浏览功能的实现
public class FoodOperator {
    //1.定义一个ArrayList集合对象，负责存储菜品对象信息
    private ArrayList<Food> foodList = new ArrayList<>();
    //foodList=[]
    //2.开发功能：上架菜品功能
    public void addFood(){
        //3.创建一个菜品对象，封装上架的菜品信息
        Food f = new Food();
        //4.录入菜品信息进去
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入该菜品名称：");
        String name = sc.next();
        f.setName(name);
​
        System.out.println("请您输入该菜品价格：");
        double price = sc.nextDouble();
        f.setPrice(price);
​
        System.out.println("请您输入该菜品描述：");
        String desc = sc.next();
        f.setDesc(desc);
        //5.把菜品对象存入到集合中去
        foodList.add(f);
        System.out.println("上架成功！");
    }
​
    //6.展示菜品
    //foodList = [f1,f2,...]
    public void showAllFoods(){
        if(foodList.size()==0) {
            System.out.println("什么菜品都没有，先去上架！");
            return;//拦截
        }
        for(int i=0;i<foodList.size();i++){
            Food f=foodList.get(i);
            System.out.println(f.getName());
            System.out.println(f.getPrice());
            System.out.println(f.getDesc());
            System.out.println("------------------------------");
        }
    }
​
    //负责展示操作界面
    public void start(){
        while(true) {
            System.out.println("请选择功能：");
            System.out.println("1.上架菜品");
            System.out.println("2.展示菜品");
            System.out.println("2.退出");
​
            Scanner sc = new Scanner(System.in);
            System.out.println("请选择您的操作：");
            String command = sc.next();
            switch (command) {
                case "1":
                    addFood();
                    break;
                case "2":
                    showAllFoods();
                    break;
                case"3":
                    System.out.println("下次再来哦！");
                    return;//干掉方法！
                default:
                    System.out.println("您输入的命令不存在");
            }
        }
    }
​
}
​

Day2 面向对象高级一

static

静态，可以修饰成员变量，成员方法

static修饰成员变量
package com.itheima.staticdemo;
​
public class Student {
    //类变量
    static String name;
    //实例变量(对象的变量)
    int age;
}
​
package com.itheima.staticdemo;
​
public class Test {
    public static void main(String[] args) {
        //1.类变量的用法
        //类名.类变量(推荐)
        Student.name="袁华";
​
        //对象.类变量(不推荐)
        Student s1 = new Student();
        s1.name = "马冬梅";
​
        Student s2 = new Student();
        s2.name="秋雅";
​
        System.out.println(s1.name);//秋雅
        System.out.println(Student.name);//秋雅
​
        //2.实例对象的用法
        //对象.实例变量
        s1.age=23;
        s2.age=18;
        System.out.println(s1.age);
    }
}
​
static修饰成员方法
package com.itheima.staticdemo2;
​
public class Student {
    double score;
    //类方法
    public static void printHelloWorld(){
        System.out.println("Hello World");
    }
    
    //实例方法(对象的方法)
    public void printPass(){
        System.out.println("成绩："+(score >= 60 ? "及格" : "不及格"));
    }
}
​
package com.itheima.staticdemo2;
​
public class Test {
    public static void main(String[] args) {
        //1.类方法的用法
        //类名.类方法(推荐)
        Student.printHelloWorld();
​
        //对象.类方法(不推荐)
        Student s = new Student();
        s.printHelloWorld();
​
        //2.实例方法的用途
        //对象.实例方法
        s.printPass();
​
    }
}
​

static修饰类方法的应用场景-工具类

为什么工具类中的方法要用类方法，而不用实例方法

  • 实例方法需要创建对象来调用，对象占内存，会浪费内存

  • 类方法直接用类名调用即可，节省内存

static注意事项

  • 类方法中可以直接访问类的成员，但不可以直接访问实例成员

  • 实例方法中既可以直接访问类成员，也可以直接访问实例成员

  • 实例方法中可以出现this关键字，类方法中不可以出现this关键字

继承

继承的特点

子类能继承父类的非私有成员（成员变量、成员方法）

继承后对象的创建

子类的对象由子类、父类共同完成的，子类、父类对外暴露什么成员，对象就可以访问什么成员

继承的好处

继承：权限修饰符

继承注意事项

  1. Java是单继承的：一个类只能继承一个直接父类；Java中的类不支持多继承，但支持多层继承

    多继承：class 子类 extends 父类A，父类B{ }

  2. Object类是Java中所有类的祖宗

Object类

class A{} 默认 extends Object{}

我们写的任何一个类，其实都是Object的子类或子孙类

方法重写

声明不变，重新实现

当子类觉得父类中的某个方法不好用，或者无法满足自己的需求时，子类可以重写一个方法名称、参数列表一样的方法，去覆盖父类的这个方法

重写后，方法的访问, Java会遵循就近原则

方法重写注意事项

方法重写的应用场景

子类中访问其他成员的特点

在子类方法中访问其他成员(成员变量、成员方法)，是依照就近原则的

成员变量

成员方法

super关键字，指定访问父类的成员：super.父类成员变量/父类成员方法

子类构造器的特点

子类的全部构造器，都会先调用父类的构造器，再执行自己

子类构造器是如何实现调用父类构造器的

  • 默认情况下，子类全部构造器的第一行代码都是super(),它会调用父类的无参数构造器

  • 如果父类没有无参数构造器，我们必须在子类构造器的第一行手写super(...),指定去调用父类的有参数构造器

子类构造器调用父类构造器的应用场景

this(...)调用兄弟构造器

任意类的构造器中，是可以通过this(...)去调用该类的其他构造器的

Day3 面向对象高级二

多态

多态是继承/实现情况下的一种现象，表现为：对象多态、行为多态

行为多态：都是同一行为但是表现出不同的状态 eg.学生跑的快，老师跑的慢 识别技巧：编译看左边，运行看右边

对象多态：都是同一对象但是表现出不同的角色 eg.人既可以是学生对象；也可以是老师对象

变量不讲多态性，所以编译看左边，运行看左边

多态下的类型转换

强转可以解决：多态下不能调子类独有功能的问题

final

可以修饰类、方法、变量

  • final修饰类，类不能被继承

  • final修饰方法，方法不能被重写

  • fianl修饰变量，只能赋值一次

抽象类

抽象类的注意事项、特点

  • 抽象类中可以不写抽象方法，但有抽象方法的类一定是抽象类

  • 类该有的成员（成员变量、方法、构造器）抽象类都可以有

  • 抽象类不能创建对象，仅作为父类让子类继承

  • 一个类继承了抽象类，必须重写完抽象类的全部抽象方法，否则自己也要是抽象类

抽象类的场景和好处

或

接口

格式：

public interface 接口名{

//成员变量(默认是常量)

//成员方法(默认是抽象方法)

}

接口不能创建对象

extends理解成亲爹；implements理解成干爹

alt+回车 选implement methods 就可以接口里的全部抽象方法都实现

接口的好处

可以解决类单继承的问题，通过接口，我们可以让一个类有一个亲爹的同时，还可以找多个干爹去扩展自己的功能

JDK8开始，接口新增的三种方法

接口的多继承

一个接口可以同时继承多个接口

public interface C extends B,A{}

生椰拿铁You
关注
  • 34
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java面向对象的特性
博客记录学习轨迹，方便日后复习
11-21 3043
SCAU面向对象程序设计复习总结——关于Java语言面向对象特性的介绍
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
JAVA面向对象
JINGJID的博客
03-25 4982
一、类与对象的创建 1.使用new关键字创建对象 Person person = new Person("Jingjing"); 二、构造器详解 一个类即使什么也不写，也会存在一个构造方法 即便前面的类是空的，仍然可以使用new方法创建一个对象 1.无参构造器和有参构造器 2.快捷方法 alt + insert :生成有参构造 alt +insert +seleteNone(弹出的中间）：生成无参构造 ...
java面向对象
黎小小的博客
08-21 4万+
本文内容是根据毕晓东老师的视频教程总结而得。包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程强调的是功能、行为 面向对象：将功能封装进对象，强调具备了功能的对象 面向对象是基于面向过程的 面向过程例子： ...
Java面向对象浅谈
编程界明世隐的博客
12-06 4965
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
Java面向对象基础
weixin_60719453的博客
10-13 8430
一、前言 我们上次学过java的方法，现在我们来学习新的一篇，也算是java中比较重要的一节了 面向对象基础是java中核心。 面向对象主要包括封装、继承、多态 我们这节主要讲的是封装，在这之前我们先来了解一下类和对象的定义和关系 什么是对象？ 世间一切都是对象，万物解释对象，对象就是看得见摸得着的东西。 什么是类？ 类是现实生活中对具有属性和行为同一类的总称。 类和对象的关系？ 类是对象的抽象化，对象是类的实例化 类的定义 ？ 类是java中的基本概念，java中
Java面向对象详解
王梦杰_MengJie
03-07 1万+
1、初识面向对象： 面向过程vs面向对象 面向过程思想：步骤清晰简单，第一步做什么，第二步做什么……，面向过程适合处理一些较为简单的问题 面向对象思想：物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后，才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理需要多人协作的问题。 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统，但是，具体到微观操作，仍然需要面向过程的思路去处理。
Java面向对象试题
热门推荐
光头强的博客
03-19 5万+
1、 请创建一个Animal动物类，要求有方法eat（）方法，方法输出一条语句“吃东西”。 创建一个接口A，接口里有一个抽象方法fly（）。创建一个Bird类继承Animal类并实现 接口A里的方法输出一条有语句“鸟儿飞翔”，重写eat（）方法输出一条语句“鸟儿 吃虫”。在Test类中向上转型创建b对象，调用eat方法。然后向下转型调用eat（）方 法、fly（）方法。 评分标准： 正确写出Ani...
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
java 面向对象 案例 合集
最新发布
07-18
java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 ...
JAVA面向对象程序设计(期末考试试题及答案)
06-16
JAVA面向对象程序设计知识点总结 JAVA面向对象程序设计是 Java 编程语言的核心 contents，涵盖了面向对象编程的基本概念、语法规则、编程技术和实际应用等方面的知识。本文总结了 JAVA面向对象程序设计的知识点，...
Java面向对象基础练习题
08-06
适合刚刚学习到面向对象三大特征的同学来巩固对知识的理解
Java面向对象程序设计
03-17
Java面向对象程序设计是计算机编程领域中的核心主题，它基于面向对象编程（OOP）理念，使得代码更具有模块化、可复用性和易于维护的特点。以下是对标题和描述中涉及的知识点的详细阐述： 1. **第1章：Java入门** -...
Java面向对象编程练习题.pdf
05-22
Java面向对象编程练习题 本资源摘要信息涵盖了 Java 面向对象编程的基础知识，通过三个练习题，展示了 Java 编程语言的基本概念和应用。 练习题 01: 类的成员变量 本练习题展示了 Java 中类的成员变量的概念。类 ...
Java面向对象逻辑思维导图
11-21
Java面向对象，自己学习整理的Java的面向对象的思维导图。
JAVA面向对象程序设计(期末考试试题及答案).pdf
03-28
Java面向对象程序设计是编程领域中的核心概念，它基于面向对象的编程思想，将现实世界中的实体抽象为类，通过类来创建对象，实现代码的复用和模块化。在这个期末考试试题中，我们看到了一系列关于Java编程的问题，...
Java面向对象基础解析
"Java面向对象（基础）" Java面向对象编程是Java语言的核心特性，它使得程序设计更加灵活和模块化。本课程是面向对象的基础入门，适合初学者学习，旨在帮助学生掌握面向对象的基本概念和技能。 1、Java可移植性 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值