Java面向对象

最新推荐文章于 2022-03-25 18:39:38 发布
最新推荐文章于 2022-03-25 18:39:38 发布
阅读量161 收藏
点赞数
分类专栏： Java基础 文章标签： java 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45467181/article/details/123171821
版权

面向对象

理解类和对象

客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。

类 ：属性+方法

类的理解

类是对现实生活中一类具有共同属性和行为的事物的抽象

类是对象的数据类型，类是具有相同属性和行为的一组对象的集合

简单理解：类就是对现实事物的一种描述

类的组成

属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）

行为：指事物能执行的操作，例如：手机事物（打电话，发短信）

类和对象的关系

类：类是对现实生活中一类具有共同属性和行为的事物的抽象

对象：是能够看得到摸的着的真实存在的实体

简单理解：类是对事物的一种描述，对象则为具体存在的事物

类的定义

类的组成是由属性和行为两部分组成

属性：在类中通过成员变量来体现（类中方法外的变量）

行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤：

①定义类

②编写类的成员变量

③编写类的成员方法

示例：

public class 类名 {
   // 成员变量
   变量1的数据类型 变量1；
   变量2的数据类型 变量2;
   …
   // 成员方法
   方法1;
   方法2;
}

范例：

/*
手机类：
    类名：
    手机(Phone)
     
     成员变量：
     品牌(brand)
     价格(price)
     
     成员方法：
     打电话(call)
     发短信(sendMessage)
*/
public class Phone {
   //成员变量
   String brand;
   int price;
    
   //成员方法
   public void call() {
      System.out.println("打电话");
   }
   public void sendMessage() {
      System.out.println("发短信");
   }
}

对象的使用

创建对象的格式：

类名 对象名 = new 类名();

调用成员的格式：

对象名.成员变量

对象名.成员方法();

示例：

/*
   创建对象
      格式：类名 对象名 = new 类名();
      范例：Phone p = new Phone();
   使用对象
      1：使用成员变量
         格式：对象名.变量名
         范例：p.brand
      2：使用成员方法
         格式：对象名.方法名()
         范例：p.call()
*/
public class PhoneDemo {
   public static void main(String[] args) {
      //创建对象
      Phone p = new Phone();
       
      //使用成员变量
      System.out.println(p.brand);
      System.out.println(p.price);
       
      p.brand = "小米";
      p.price = 2999;
       
      System.out.println(p.brand);
      System.out.println(p.price);
       
      //使用成员方法
      p.call();
      p.sendMessage();
   }
}

学生对象应用

需求：首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量和成员方法 的使用

分析：

成员变量：姓名，年龄…

成员方法：学习，做作业…

示例：

class Student {
   //成员变量
   String name;
   int age;
    
   //成员方法
   public void study() {
      System.out.println("好好学习，天天向上");
   }
    
   public void doHomework() {
      System.out.println("键盘敲烂，月薪过万");
   }
}
/*
   学生测试类
*/
public class StudentDemo {
   public static void main(String[] args) {
   //创建对象
   Student s = new Student();
       
   //使用对象
   System.out.println(s.name + "," + s.age);
   s.name = "林青霞";
   s.age = 30;
       
   System.out.println(s.name + "," + s.age);
       
   s.study();
   s.doHomework();
   }
}

对象内存图

理解单个对象内存图

成员变量使用过程

public class StudentTest{
    public static void main(String[] args){
        /*
        栈内存：main
                Student s  001
        堆内存：new Student()
                 001
                 name "张曼玉"
                 age  28
                 
         输出：001
         输出：null
         输出：张曼玉，28
         */
        
        //创建对象
        Student s = new Student();
        System.out.println(s);
        
        //使用成员变量
        System.out.println(s.name+","+s.age);
        s.name ="张曼玉"
        s.age = 28;
        System.out.println(s.name+","+s.age);
        
        //使用成员方法
        s.study();
        s.doHomework();
    }
}

成员方法调用过程

public class Student{
    //成员变量
    String name;
    int age;
    //成员方法
    public void study(){
        System.out.println("好好学习")；
    }
    public void doHomework(){
        System.out.println("多做练习")；
    }
}
/*
栈内存：
方法：doHomework
调用者： s (001)

方法：main
Student s 001

堆内存：
new Student()

001
name "张曼玉"
age 28
*/

/*
输出：
    001
    null,0
    张曼玉，28
    
输出：
    好好学习
    多做练习
*/

理解多个对象内存图

成员变量使用过程

public class StudentTest01{
    public static void main(String[] args){
        //创建第一个对象并使用
        Student s1 = new Student();
        s1.name="林青霞"；
        s1.age=30;
        System.out.println(s1.name+","+s1.age);
        s1.study();
        s1.doHomework();
        
        //创建第二个对象并使用
        Student s2 =new Student();
        s2.name="张曼玉"；
        s2.age=28;
        System.out.println(s2.name+","+s2.age);
        s2.study();
        s2.doHomework();
    }
}
/*
栈内存：
方法：main
   Student s1   001
   Student s2   002
堆内存;
   new Student()
   001
   name "林青霞"
   age 30
   
   new Student()
   002  
   name "张曼玉"
   age  28
*/
/*
输出：林青霞，30  张曼玉，28
输出：好好学习
输出：多做练习
*/

成员方法调用过程

public class StudentTest01{
    public static void main(String[] args){
        //创建第一个对象并使用
        Student s1 = new Student();
        s1.name="林青霞"；
        s1.age=30;
        System.out.println(s1.name+","+s1.age);
        s1.study();
        s1.doHomework();
        
        //创建第二个对象并使用
        Student s2 =new Student();
        s2.name="张曼玉"；
        s2.age=28;
        System.out.println(s2.name+","+s2.age);
        s2.study();
        s2.doHomework();
    }
}
/*
栈内存;
方法： main
Student s1 001
Student s2 002
堆内存：
new Student()
   001
   name "林青霞"
   age 30
   
   new Student()
   002  
   name "张曼玉"
   age  28
*/
/*
输出：林青霞，30 张曼玉，28
输出：好好学习 好好学习
输出：多做练习 多做练习

总结： 多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的 一份

理解多个对象指向相同内存图

public class StudentTest02{
    public static void main(String[] args){
        //创建第一个对象并使用
        Student s1 =new Student();
        s1.name="林青霞"；
        s2.age=30;
        System.out.println(s1.naem+","+s2.age);
        
        //把第二个对象的地址赋值给第二个对象
        Student s2 = s1;
        s2.name="张曼玉"；
        s2.age=28;
        System.out.println(s1.name+","s1.age);
        System.out.println(s2.name+","s2.age);        
    }
}
/*
栈内存：
方法:main
Student s1 001
Student s2 002

堆内存：
new Student()
001
name "张曼玉"
age 28

输出:
    林青霞，30
    张曼玉，28
    张曼玉，28
总结:
当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）

只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。
    
*/

成员变量和局部变量

理解成员变量和局部变量的区别

类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）

内存中位置不同：成员变量（堆内存）局部变量（栈内存）

生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而 存在，醉着方法的调用完毕而消失）

初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

封装

理解private关键字

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

示例：

/*
   学生类
*/
class Student {
   //成员变量
   String name;
   private int age;
    
   //提供get/set方法
   public void setAge(int a) {
      if(a<0 || a>120) {
         System.out.println("你给的年龄有误");
      } else {
         age = a;
      }
   }
   public int getAge() {
      return age;
   }
    
   //成员方法
   public void show() {
      System.out.println(name + "," + age);
   }
}

/*
   学生测试类
*/
public class StudentDemo {
   public static void main(String[] args) {
      //创建对象
      Student s = new Student();
       
      //给成员变量赋值
      s.name = "林青霞";
      s.setAge(30);
       
      //调用show方法
      s.show();
   }
}

private的使用

需求：

定义标准的学生类，要求name和age使用private修饰，并提供set和get方法以及便于显示数据的show

方法，测试类中创建对象并使用，最终控制台输出 林青霞，30

示例:

/*
   学生类
*/
class Student {
   //成员变量
   private String name;
   private int age;
    
   //get/set方法
   public void setName(String n) {
      name = n;
   }
   public String getName() {
      return name;
   }
   public void setAge(int a) {
      age = a;
   }
   public int getAge() {
      return age;
   }
   public void show() {
      System.out.println(name + "," + age);
   }
}


/*
   学生测试类
*/
public class StudentDemo {
   public static void main(String[] args) {
      //创建对象
      Student s = new Student();
       
      //使用set方法给成员变量赋值
      s.setName("林青霞");
      s.setAge(30);
      s.show();
       
      //使用get方法获取成员变量的值
      System.out.println(s.getName() + "---" +s.getAge());
      System.out.println(s.getName() + "," + s.getAge());
   }
}

this关键字

this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量

方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

public class Student {
   private String name;
   private int age;
    
   public void setName(String name) {
      this.name = name;
   }
    
   public String getName() {
      return name;
   }
    
   public void setAge(int age) {
      this.age = age;
   }
    
   public int getAge() {
      return age;
   }
    
   public void show() {
      System.out.println(name + "," + age);
   }
}

理解this内存原理

this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象

示例:

public class StudentDemo {
   public static void main(String[] args) {
      Student s1 = new Student();
      s1.setName("林青霞");
      Student s2 = new Student();
      s2.setName("张曼玉");
   }
}

解析：

public class StudentDemo{
    public static void main(String[] args){
        Student s1 = new Student();
        s1.setName = ("林青霞")；
        
        Student s2 = new Student();
        s2.setName = ("张曼玉")；
            
    }
}
/*
栈内存：
方法：setName
参数：name:"张曼玉"
调用者：s2(002)
this:s2(002)

方法：main
Student s1  001
Student s2  002

堆内存：
new Student()
001
name "林青霞"
age 0

new Student()
002
name "张曼玉"
age 0
*/

public class Student{
    private String name;
    
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
}

/*
方法：setName       方法:setName
参数：name:"林青霞"  参数：name:"张曼玉"
调用者：s1(001)     调用者：s2(002)
this: s1(001)      this:s2(002)
*/

理解封装思想

  1. 封装概述 是面向对象三大特征之一（封装，继承，多态） 是面向对象编程语言对客观世界的模拟，客观世界 里成员变量都是隐藏在对象内部的，外界是无法直接操作的
  2. 封装原则 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法
  3. 封装好处 通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性

构造方法

理解构造方法

构造方法是一种特殊的方法

作用：创建对象 Student stu = new Student();

格式：

public class 类名{

修饰符 类名( 参数 ) {

}

}

功能：主要是完成对象数据的初始化

示例：

class Student {
   private String name;
   private int age;
    
   //构造方法
   public Student() {
      System.out.println("无参构造方法");
   }
    
   public void show() {
      System.out.println(name + "," + age);
   }
}
/*
   测试类
*/
public class StudentDemo {
   public static void main(String[] args) {
      //创建对象
      Student s = new Student();
      s.show();
   }
}

理解构造方法的注意事项

构造方法的创建

如果没有定义构造方法，系统将给出一个默认的无参数构造方法 如果定义了构造方法，系统将不再提供默认的构造方法

构造方法的重载

如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

推荐的使用方式

无论是否使用，都手工书写无参数构造方法

重要功能：可以使用带参构造，为成员变量进行初始化

示例：

/*
   学生类
*/
class Student {
   private String name;
   private int age;
    
   public Student() {}
    
   public Student(String name) {
      this.name = name;
   }
    
   public Student(int age) {
      this.age = age;
   }
   public Student(String name,int age) {
      this.name = name;
      this.age = age;
   }
    
   public void show() {
      System.out.println(name + "," + age);
   }
}

/*
   测试类
*/
public class StudentDemo {
   public static void main(String[] args) {
      //创建对象
      Student s1 = new Student();
      s1.show();
       
      //public Student(String name)
      Student s2 = new Student("林青霞");
      s2.show();
       
      //public Student(int age)
      Student s3 = new Student(30);
      s3.show();
       
      //public Student(String name,int age)
      Student s4 = new Student("林青霞",30);
      s4.show();
   }
}

标准类制作

需求：定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有 参创建的对象直接赋值，并通过show方法展示数据。

示例：

class Student {
   //成员变量
   private String name;
   private int age;
    
   //构造方法
   public Student() {
   }
    
   public Student(String name, int age) {
      this.name = name;
      this.age = age;
   }
    
   //成员方法
   public void setName(String name) {
      this.name = name;
   }
    
   public String getName() {
      return name;
   }
    
   public void setAge(int age) {
      this.age = age;
   }
    
   public int getAge() {
      return age;
   }
    
   public void show() {
      System.out.println(name + "," + age);
   }
}

/*
创建对象并为其成员变量赋值的两种方式
1:无参构造方法创建对象后使用setXxx()赋值
2:使用带参构造方法直接创建带有属性值的对象
*/

public class StudentDemo {
   public static void main(String[] args) {
      //无参构造方法创建对象后使用setXxx()赋值
      Student s1 = new Student();
      s1.setName("林青霞");
      s1.setAge(30);
      s1.show();
      //使用带参构造方法直接创建带有属性值的对象
      Student s2 = new Student("林青霞"，30);
      s2.show();
   }
}

继承

继承的本质是对一批类的抽象，从而实现对现实世界更好的建模。

extands的意思是“扩展”。子类是父类的扩展。

Java中类只有单继承，没有多继承。

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

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

子类和父类之间，从意义上讲应该具有“is a"关系。

object类

super

方法重写

package com.oop.demo;
//Person 人 :父类（基类）
//学生 is 人 :子类（派生类）
//子类继承了父类，就会拥有父类的所有方法！
//public class Person{
public class Student extends Person{
    public int money = 10_0000_0000;
    
    public void say(){
        System.out.println("说了一句话");
    }    
}

package com.oop;
import com.oop.demo.Student;
public class Application{
    public static void main(String[] args){
        
        Student student = new Student();
        student.say();
        System.out.println(student.money);
    }
}
/*
修饰符:
public 公共的
protected 受保护的
default 默认的
private 私有的 一般属性才是私有的
*/


public class Person{
   private int money = 10_0000_0000;
   public int getMoney(){
       return money;
   }
   public void setMoney(int money){
       this.money = money;
   }
}  //继承、封装思想

在Java中，所有的类，都默认直接或间接继承object类

public class Person/*extends Object*/{
    
}

Ctrl+H 打开继承树

super

package com.oop.demo;

//在Java中，所有的类，都默认直接或间接继承object类
//Person 人 :父类（基类）
public class Person/*extends Object*/{
    
    public Person(){
        System.out.println("Person无参执行了");
    }
    
    
    protected String name = "feng";
    //private void print(){   私有的东西无法被继承
    public void print(){
        System.out.println("Person");
    }
}


package com.oop.demo;
//学生 is 人 :子类（派生类）
//子类继承了父类，就会拥有父类的所有方法！
public class Student extends Person{
    
    public Student(){
        //隐藏代码：调用了父类的无参构造  super();
        //super();调用父类的构造器，必须要在子类构造器第一行
        //this(name:"hello");
        System.out.println("Student无参执行了");
    }
    
    
    private String name = "ting";
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();  //Student
        this.print(); //Student
        super.print(); //Person
    }
    
    public void test(String name){
        System.out.println(name);  //婷
        System.out.println(this.name);  //ting
        System.out.println(super.name);  //feng
        
    }
}

package com.oop;
import com.oop.demo.Person;
public class Application{
    public static void main(String[] aegs){
        Student student = new Student();
      //student.test(name:"婷");
      //student.test1();
    }
}

注意：

  1. super调用父类的构造方法，必须在构造方法的第一个

  2. super必须只能出现在子类的方法或者构造方法中

  3. super和this不能同时调用构造方法

  4. VS this

    代表对象不同：

    this：本身调用者这个对象

    super：代表父类对象的应用

    前提：

    this：没有继承也可以使用

    super：只能在继承条件才可以使用

    构造方法：

    this：本类的构造

    super：父类的构造

方法重写

A类 (A类继承B类)

package com.oop.demo;
//继承
public class A extends B{
    //Override 重写
    @Override //注释：有功能的注释
    public static void test(){
        System.out.println("A=>test()");
    }
    
}

B类

package com.oop.demo;
//重写都是方法的重写，和属性无关
public class B{
    public static void test(){
        System.out.println("B=>test()");
        
    }
    
}

测试类Application

package com.oop;
import com.oop.demo.A;
   public class Application{
       //静态的方法和非静态的方法区别很大
       public static void main(String[] args){
           //方法的调用只和左边定义的数据类型有关（静态）
           //非静态：重写
           A a = new A();
           a.test();  //A
           
           //父类的引用指向了子类
           B b = new A();  //子类重写了父类的方法
           b.test();  //B
   }
}

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

  1. 方法名必须相同

  2. 参数列表列表必须相同

  3. 修饰符：范围可以扩大但不能缩小public=>Protected=>Default=>private

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

    ClassNoteFoundException–>Exception(大)

  5. 重写：子类的方法和父类必须一致，方法体不同

  6. 需要重写的原因：

    1. 父类的功能，子类不一定需要或者不一定满足
    2. Alt+Insert：选中override

多态

动态编译：类型：可扩展性

即同一方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）

多态存在的条件

有继承关系

子类重写父类方法

父类引用指向子类对象

注意：多态是方法的多态，属性没有多态性

instanceof （类型转换 ）引用类型

Application

import com.oop.demo.Person;
import com.oop.demo.Student;

public class Application{
    public static void main(String[] args){
        //一个对象的实际类型是确实的
        //new Student();
        //new Person();
        
        //可以指向的引用类型就不确定了：父类的引用类型指向子类
        
        //Student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person父类型可以指向子类，但是不能调用子类独有的方法
        Person S2 = new Student();
        Object S3 = new Student();
       
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        s2.run();
        ((Student) S2.eat();//强转
        //s2.eat();  //子类重写了父类的方法，执行子类的方法
        S1.eat();
        
    }
}

Person

package com.oop.demo;
public class Person{
   public void run(){
       System.out.println("run");
   
   }
}

Student

package com.oop.demo;
public class Student extends Person{
   
   @Override
   public void run(){
      System.out.println("son");
   }

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

}

多态注意事项：

  1. 多态是方法的多态，属性没有多态
  2. 父类和子类有联系 类型转换异常 ClassCastException
  3. 存在条件：有继承关系，方法需要重写，父类引用指向子类对象 Father f1 = new Son();(抽象建模)
  4. static 方法属于类，它不属于实例
  5. final常量
  6. private方法
Java-feng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java面向对象的特性
博客记录学习轨迹，方便日后复习
11-21 2959
SCAU面向对象程序设计复习总结——关于Java语言面向对象特性的介绍
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
类和对象
qq_45373670的博客
10-01 592
类和对象 客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。 类 类的理解 类是对现实生活中一类具有共同属性和行为的事物的抽象 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合 简单理解：类就是对现实事物的一种描述 类的组成 属性：指事物的特征，例如：手机事物（品牌，价格，尺寸） 行为：指事物能执行的操作，例如：手机事物（打电话，发短信） 类和对象的关系 类：类...
java 9对象_java(9)类和对象
weixin_28727943的博客
02-27 53
一、理解什么是类和对象万事万物皆对象1.1、属性——对象具有的特征(特点)1.2、方法——对象可执行的操作(能干什么事)1.3、对象的定义：是一个客观存在的，看的见或摸得着的实体，由属性和方法构成1.4、类是由对象抽象出来的，看不见也摸不着1.5、类和对象的关系？类(是笼统)是模子是对象的抽象化，对象(具体的)是类的具体化二、封装——包装(把一个事物包装起来，并尽可能隐藏内部细节)2.1、2种表现...
JAVA面向对象
JINGJID的博客
03-25 4918
一、类与对象的创建 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 4839
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
Java面向对象基础
weixin_60719453的博客
10-13 8277
一、前言 我们上次学过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面向对象编程测试题.docx
11-10
JAVA面向对象考试题 50道基础选择题，肯定的有一道适合你， 相信，不会有错 java面向对象题型你的不二选择
JAVA面向对象程序设计(期末考试试题及答案)
06-16
JAVA面向对象程序设计知识点总结 JAVA面向对象程序设计是 Java 编程语言的核心 contents，涵盖了面向对象编程的基本概念、语法规则、编程技术和实际应用等方面的知识。本文总结了 JAVA面向对象程序设计的知识点，...
Java面向对象基础练习题
08-06
适合刚刚学习到面向对象三大特征的同学来巩固对知识的理解
Java面向对象逻辑思维导图
11-21
Java面向对象，自己学习整理的Java的面向对象的思维导图。
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计(源代码+课后习题答案)（耿祥义 张跃平 清华大学出版社）
java 面向对象课本
07-25
Java OOP面向对象Java OOP面向对象 Java OOP面向对象Java OOP面向对象
Java面向对象程序设计
最新发布
02-19
包括设计步骤，代码设计注释，思路，以及源代码
java面向对象编程 电子书
09-22
Java面向对象编程电子书是一本详细介绍Java面向对象编程概念、原理和实践的电子书籍。本书从基础概念开始，逐步深入到高级主题，使读者能够全面理解Java面向对象编程的核心思想和技术。 首先，本书会介绍面向对象...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值