JavaSE---03面向对象(上)

最新推荐文章于 2024-05-11 10:24:57 发布
最新推荐文章于 2024-05-11 10:24:57 发布
阅读量182 收藏
点赞数
分类专栏： JAVA相关 # SE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feverd555/article/details/124903737
版权

引言：该内容为作者学习java期间所作笔记，学习参考尚硅谷系列视频。

 

03 面向对象(上)

3.1 概述

学习面向对象内容的三条主线

1.Java 类及类的成员：属性、方法、构造器、代码块、内部类

2.面向对象的三大特征：封装、继承、多态性、(抽象性)

3.其它关键字：this、super、static、final、abstract、interface、package、import 等

面向对象举例--把大象装进冰箱

 1.面向过程:强调的是功能行为，以函数为最小单位，考虑怎么做。
  ① 打开冰箱
  ② 把大象装进冰箱
  ③ 把冰箱门关住 
     
 2.面向对象:强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
 人{
     打开(冰箱){
         冰箱.开门();
     }操作(大象){
         大象.进入(冰箱);
     }关闭(冰箱){
         冰箱.关门();     
     }
 }
  
 冰箱{
     开门(){
     }  
     关门(){
     }
  }
  
 大象{
     进入(冰箱){
     }
  }

面向对象的两个要素

类:对一类事物的描述，是抽象的、概念上的定义

对象:是实际存在的该类事物的每个个体，因而也称为实 例(instance)。

可以理解为：类= 抽象概念的人；对象= 实实在在的某个人

3.2 内存解析

img

案例

 Person p1= newPerson();
 p1.name = "Tom";
 p1.isMale = true;
 Person p2 = new Person();
 sysout(p2.name);//null
 Person p3 = p1;
 p3.age = 10;//此时p1.age也是10

img

3.3 属性和方法

类中定义成员和方法，不能直接进行运算，可以写在代码块{}或者静态代码块中static{}中

3.3.1 属性（成员变量）vs 局部变量

 1.相同点:
     1.1 定义变量的格式:数据类型 变量名 = 变量值
     1.2 先声明，后使用
     1.3 变量都有其对应的作用域
                 
 2.不同点:
     2.1 在类中声明的位置不同
     属性:直接定义在类的一对{}内
     局部变量:声明在方法内、方法形参、构造器形参、构造器内部的变量
 ​
     2.2 关于权限修饰符的不同
     属性:可以在声明属性时，指明其权限，使用权限修饰符。
         常用的权限修饰符:private、public、缺省、protected
         目前声明属性时，都使用缺省即可。
     局部变量:不可以使用权限修饰符。
  
     2.3 默认初始化值的情况:
     属性:类的属性，根据其类型，都有默认初始化值。
         整型(byte、short、int、long):0
         浮点型(float、double):0.0
         字符型(char):0(或‘\u0000’)
         布尔型(boolean):false
         引用数据类型(类、数组、接口):null
     局部变量:没有默认初始化值
         意味着:在调用局部变量之前，一定要显式赋值。
         特别地:形参在调用时,赋值即可
             
     2.4 在内存中加载的位置，亦各不相同。
     属性:加载到堆空间中(非 static)
     局部变量:加载到栈空间
 ​

3.3.2 带返回值return的方法

 返回值类型： 有返回值  vs 没有返回值
 1  如果方法有返回值，则必须在方法声明时，指定返回值的类型。
     *同时，方法中需要使用return关键字来返回指定类型的变量或常量：“return 数据”。
     *如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要
      使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
 ​
 2 我们定义方法该不该有返回值？
  ① 题目要求
  ② 凭经验：具体问题具体分析
          
 3 return关键字的使用：
     1.使用范围:使用在方法体中
     2.作用:① 结束方法
           ② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
     3.注意点:return关键字后不可声明执行语句。

3.4 对象数组的内存解析

引用类型的变量，只可能存储量两类值：null或地址值（含变量类型）

 

 

示例

 public class JustTest {
     public static void main(String[] args) {
         Car[] car = new Car[5];
         System.out.println(car);   //[LCar;@723279cf
         System.out.println(car[1]);//null
         car[1] = new Car();
         System.out.println(car[1]);//Car@b4c966a
     }
 }
 class Car{
 }

3.5 匿名对象

 /* 
  * 匿名对象的使用
  * 1.理解:我们创建的对象，没有显示的赋值给一个变量名。即为匿名对象。
  * 2.特征：匿名对象只能调用一次。
  * 3.使用:如下
  */
 public class InstanceTest {
     public static void main(String[] args) {
         Phone p = new Phone();
 //      p = null;
         System.out.println(p);//地址值
         
         p.sendEmail();
         p.playGame();
         
         //匿名对象
 //      new Phone().sendEmail();
 //      new Phone().playGame();
         
         new Phone().price = 1999;
         new Phone().showPrice();//0.0，前面调用一次，这又是一个新的匿名对象，所以是0.0
         
 //**************************************************
         PhoneMall mall = new PhoneMall();
         //开发中匿名对象的使用
         mall.show(new Phone()); //在这里就相当于用了两次：send和play
     }
 }
 ​
 class PhoneMall{
     public void show(Phone phone){
         phone.sendEmail();
         phone.playGame();
     }
 }
 ​
 class Phone{
     double price;   //价格
     
     public void sendEmail(){
         System.out.println("发邮件");
     }
     public void playGame(){
         System.out.println("打游戏");
     }
     public void showPrice(){
         System.out.println("手机价格为:" + price);
     }
 }

3.6 方法的重载overload

定义

  • 在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

  • 两同一不同：同一个类、相同方法名

参数列表不同：参数个数不同，参数类型不同(前后顺序不同也算)

  • 与方法的返回值类型、权限修饰符、形参变量名、方法体都无关

示例

 public static void main(String[] args) {
         OverLoadTest test = new OverLoadTest();
         test.getSum(1, 2);  //调用的第一个，输出1
     }
 ​
     //如下的四个方法构成了重载
     public void getSum(int i,int j){
         System.out.println("1");
     }
     public void getSum(double d1,double d2){
         System.out.println("2");
     }
     public void getSum(String s,int i){
         System.out.println("3");
     }
     
     public void getSum(int i,String s){
         
     }

3.7 可变个数形参

定义

允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

具体使用

  • 可变个数形参的格式：数据类型 ... 变量名

  • 当调用可变个数形参的方法时，传入的参数的个数可以是：0个，1个，2个...

  • 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。

  • 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。即二者不可共存。

  • 可变个数形参在方法中的形参中,必须声明在末尾。

  • 可变个数形参在方法中的形参中，最多只能声明一个可变形参。

示例

 //1.不共存
 public void show(String ... strs) {
     for (int i = 0; i < strs.length; i++) {//也有length属性
         System.out.println(strs[i]);
     }
 }
 // 此方法与上一方法不可共存
 // public void show(String[] strs){
 //
 // }
 ​
 //2.必须末尾
 public void show(String ... strs,int i) {//错误，会报错
 }
 public void show(int i，String ... strs) {//正确
 }

3.8 方法参数的值传递机制（重点）

关于变量的赋值

  • 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。

  • 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

3.8.1 对于基本数据类型

 /*
  * 方法的形参的传递机制：值传递
  * 
  * 1.形参：方法定义时，声明的小括号内的参数
  *   实参：方法调用时，实际传递给形参的数据
  * 2.值传递机制：
  *  如果参数是基本数据类型，此时实参赋值给形参的是实参真是存储的数据值。
  */
 public class ValueTransferTest1 {
     public static void main(String[] args) {
     
         int m = 10;
         int n = 20; 
         System.out.println("m = " + m + ", n = " + n);
         //交换两个变量的值的操作
 //      int temp = m;
 //      m = n;
 //      n = temp;
         ValueTransferTest1 test = new ValueTransferTest1();
         test.swap(m, n);
         System.out.println("m = " + m + ", n = " + n);  //发现m与n并未交换
     }
     
     public void swap(int m,int n){
         int temp = m;
         m = n;
         n = temp;
     }
 }

 

 

3.8.2 对于引用数据类型

 /*
  *  如果参数是引用数据类型，此时实参赋值给形参的是实参存储数据的地址值。
  */
 public class ValueTransferTest2 {
     public static void main(String[] args) {
         Data data = new Data();
 ​
         data.m = 10;
         data.n = 20;
         System.out.println("m = " + data.m + ", n = " + data.n);
 ​
         //交换m和n的值
 //      int temp = data.m;
 //      data.m = data.n;
 //      data.n = temp;
         
         ValueTransferTest2 test = new ValueTransferTest2();
         test.swap(data);//因为把地址赋给了形参，一换都换
         System.out.println("m = " + data.m + ", n = " + data.n);
     }
     
     public void swap(Data data){
         int temp = data.m;
         data.m = data.n;
         data.n = temp;
     }
 }
 ​
 class Data{
     int m;
     int n;
 }

 

3.8.3 相关题目

题目1

 /*
 *画出下面代码的内存分析
 */
 public class TransferTest3{
     public static void main(String args[]){
         TransferTest3 test=new TransferTest3();
         test.first();
     }
     
     public void first(){
         int i=5;
         Value v=new Value();
         v.i=25;
         second(v,i);
         System.out.println(v.i);
     }
     
     public void second(Value v,int i){
         i=0;
         v.i=20;
         Value val=new Value();
         v=val;
         System.out.println(v.i+" "+i);
         
     }
 }
 class Value {
     int i= 15;
 }

 

 

题目2

 

 public static void method(int a,int b){
     a = a * 10;
     b = b * 20;
     System.out.println(a);
     System.out.println(b);
     System.exit(0);//使程序强制结束跳过main中的两个println
 }

题目3

 /*
  * 微软：
  * 定义一个int型的数组：int[] arr = new int[]{12,3,3,34,56,77,432};
  * 让数组的每个位置上的值去除以首位置的元素，得到的结果，作为该位置上的新值。遍历新的数组。 
  */
 ​
 //错误写法
 for(int i= 0;i < arr.length;i++){
     arr[i] = arr[i] / arr[0];
 }
 //正确写法1
 for(int i = arr.length –1;i >= 0;i--){//倒着来
     arr[i] = arr[i] / arr[0];
 }
 //正确写法2
 int temp = arr[0];
 for(int i= 0;i < arr.length;i++){
     arr[i] = arr[i] / temp;
 }

题目4

 

 

 public class CircleTest {
     public static void main(String[] args) {
         PassObject p = new PassObject();
         p.printAreas(new Circle(), 5);
     }
 }
 ​
 class Circle{
     double radius;
 ​
     public double findArea(){
         return Math.PI * radius * radius;
     }
 }
 ​
 class PassObject{
 ​
     public void printAreas(Circle c, int time){
         System.out.println("Radius\t\t\tArea");
         for (int i = 0;i < time;i++){
             c.radius = (double)(i+1);
             System.out.println(c.radius + "\t\t\t" + c.findArea());
         }
     }
 }

3.9 递归

概念

1.递归方法：一个方法体内调用它自身。

2.方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。

3.递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

示例

 // 例1:计算1-n之间所有自然数的和
 public int getSum(int n) {
     if (n == 1) {
         return 1;
     } else {
         return n + getSum(n - 1);
     }
 }
 ​
 // 例2:计算1-n之间所有自然数的乘积
 //归求阶乘(n!)的算法
 public int getSum1(int n) {
     if (n == 1) {
         return 1;
     } else {
         return n * getSum1(n - 1);
     }
 }
 ​
 //例4:已知一个数列：f(20) = 1,f(21) = 4,f(n+2) = 2*f(n+1)+f(n),
 //其中n是大于0的整数，求f(10)的值。
 public int f1(int n){
     if(n == 20){
         return 1;
     }else if(n == 21){
         return 4;
     }else{
         return 2*f1(n-1) + f1(n-2);//关键，把n+改为n-
     }
 }

3.10 封装和隐藏

把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

示例

 /*
 面向对象的特征一:封装与隐藏
 一、问题的引入：
     当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。但除此之外，没有其他制约条件。但是，实际问题中，我们往往需要给属性赋值加入额外限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行条件的添加。比如说，setLegs同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的(private) ，此时，针对于属性就体现了封装性。
 二、封装性的体现：
     我们将类的属性私有化(private),同时,提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值。
     拓展：封装性的体现：① 如上 ② 单例模式 ③ 不对外暴露的私有方法 ...
  */
 public class AnimalTest {
 ​
     public static void main(String[] args) {
         Animal a = new Animal();
         a.name = "大黄";
 //      a.legs = 4;//The field Animal.legs is not visible
         a.show();
 ​
 //      a.setLegs(6);
         a.setLegs(-6);
         
 //      a.legs = -4;//The field Animal.legs is not visible
         a.show();
         
         System.out.println(a.name);
         System.out.println(a.getLegs());
     }
 }
 class Animal{
     
     String name;
     private int age; //加上private则只能在类里使用，所以在main中就没法直接赋值了
     private int legs; //腿的个数
     
     //对于属性的设置
     public void setLegs(int l){
         if(l >= 0 && l % 2 == 0){
             legs = l;
         }else{
             legs = 0;
         }
     }
     
     //对于属性的获取
     public int getLegs(){
         return legs;
     }
     
     public void eat(){
         System.out.println("动物进食");
     }
     
     public void show(){
         System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
     }
     
     //提供关于属性 age 的 get 和 set 方法
     public int getAge(){
         return age;
     }
     
     public void setAge(int a){
         age = a;
     }
 }

3.11 四种权限修饰符

 封装性的体现，需要权限修饰符来配合。
     1.Java 规定的 4 种权限：(从小到大排序)private、缺省、protected、public
     2.4 种权限用来修饰类及类的内部结构：属性、方法、构造器、内部类
     3.具体的，4 种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
       修饰类的话，只能使用：缺省、public
 总结封装性：Java 提供了 4 中权限修饰符来修饰类积累的内部结构，体现类及类的内部结构的可见性的方法。

图片: https://uploader.shimo.im/f/BnOxeu6anBqhLyCW.png

3.12 构造器

概念

类的结构之三:构造器(构造方法、constructor)

一、构造器的作用:

1.创建对象

2.初始化对象的属性（这样就不必每次实例化时都进行赋值了，出生就有某种属性）

二、说明

1.如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器。

2.定义构造器的格式：权限修饰符 类名(形参列表) { }

3.一个类中定义的多个构造器，彼此构成重载。

4.一旦显示的定义了类的构造器之后，系统不再提供默认的空参构造器。

5.一个类中，至少会有一个构造器

示例

 public class PersonTest {
 ​
     public static void main(String[] args) {
         //创建类的对象:new + 构造器
         Person p = new Person();    //Person()这就是构造器
         p.eat();
         Person p1 = new Person("Tom");
         System.out.println(p1.name);
     }
 }
 class Person{
     //属性
     String name;
     int age;
     
     //构造器
     public Person(){
         System.out.println("Person()......");
     }
     
     public Person(String n){
         name = n;
     }
     
     public Person(String n,int a){
         name = n;
         age = a;
     }
     
     //方法
     public void eat(){
         System.out.println("人吃饭");
     }
     
     public void study(){
         System.out.println("人学习");
     }
 }

3.12 总结属性赋值的过程

 /*
  * 总结:属性赋值的先后顺序
  * 
  * ① 默认初始化值
  * ② 显式初始化
  * ③ 构造器中赋值
  * ④ 通过"对象.方法" 或 “对象.属性”的方式，赋值
  * 
  * 以上操作的先后顺序:① - ② - ③ - ④ 
  * 
  */
 public class UserTest {
     public static void main(String[] args) {
         User u = new User();
         System.out.println(u.age);
         
         User u1 = new User(2);
         u1.setAge(3);
         System.out.println(u1.age);//3
     }
 }
 class User{
     String name;
     int age = 1;//显式    
     
     public User(){}
     
     public User(int a){//构造器
         age = a;
     }
     
     public void setAge(int a){//对象方法赋值
         age = a;
     }
 }

3.13 JavaBean

 /*
  * JavaBean 是一种 Java 语言写成的可重用组件。
  * 所谓 javaBean，是指符合如下标准的 Java 类：
  *      > 类是公共的
  *      > 有一个无参的公共的构造器
  *      > 有属性，且有对应的 get、set 方法
  */
 public class Customer {
     
     private int id;
     private String name;
 ​
     public Customer(){}
     public void setId(int i){
         id = i;
     }
     public int getId(){
         return id;
     }   
     public void setName(String n){
         name = n;
     }
     
     public String getName(){
         return name;
     }
 }

3.14 UML类图

img

  • +表示 public 类型，-表示 private 类型，#表示 protected 类型

3.15 关键字this的使用

 this 关键字的使用
 1.this 用来修饰、调用：属性、方法、构造器
 ​
 2.this 修饰属性和方法:
         this 理解为：当前对象,或当前正在创建的对象。 
     2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性和方法。
     通常情况下，我们都选择省略“this.”。特殊情况下，如果方法的形参和类的属性同名，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
     2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用正在创建的对象属性和方法。
     但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果构造器的形参和类的属性同名，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
 3.this 调用构造器
     ① 我们可以在类的构造器中，显式的使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
     ② 构造器中不能通过"this(形参列表)"的方式调用自己。
     ③ 如果一个类中声明了n个构造器，则最多有n-1个构造器中使用了"this(形参列表)"。
     ④ "this(形参列表)"必须声明在类的构造器的首行！
     ⑤ 在类的一个构造器中，最多只能声明一个"this(形参列表)"。

示例

 public class PersonTest {
     public static void main(String[] args) {
         Person p1 = new Person();
         
         p1.setAge(1);
         System.out.println(p1.getAge());
         
         p1.eat();
         System.out.println();
         
         Person p2 = new Person("jerry" ,20);//会输出那一句话
         System.out.println(p2.getAge());
     }
 }
 class Person{
     
     private String name;
     private int age;
     
     public Person(){
         this.eat();
         String info = "Person 初始化时，需要考虑如下的 1,2,3,4...(共 40 行代码)";
         System.out.println(info);
     }
     
     public Person(String name){
         this();//关键！调了Person（）构造器
         this.name = name;
     }
     
     public Person(int age){
         this();
         this.age = age;
     }
     
     public Person(String name,int age){
         this(age);  //调用构造器的一种方式
         this.name = name;
 //      this.age = age;
     }
     
     public void setName(String name){
         this.name = name;
     }
     public String getName(){
         return this.name;
     }
     public void setAge(int age){
         this.age = age;
     }
     public int getAge(){
         return this.age;
     }
     public void eat(){
         System.out.println("人吃饭");
         this.study();
     }
     public void study(){
         System.out.println("学习");
     }
 }

3.16 关键字package、import

package

 package关键字的使用
 1.为了更好的实现项目中类的管理，提供包的概念
 2.使用package声明类或接口所属的包，声明在源文件的首行
 3.包，属于标识符，遵循标识符的命名规则、规范"见名知意"
 4.每“.”一次,就代表一层文件目录。
 ​
 补充:同一个包下，不能命名同名接口或同名类
     不同包下，可以命名同名的接口、类。

improt

 import关键字的使用
 import:导入
 1.在源文件中显式的使用import结构导入指定包下的类、接口
 2.声明在包的声明和类的声明之间
 3.如果需要导入多个结构，则并列写出即可
 4.可以使用"xxx.*"的方式,表示可以导入xxx包下的所有结构。
 5.如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
 6.如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个。
 7.如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
 8.import static组合的使用：调用指定类或接口下的静态的属性或方法.
Double&Mint
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象程序设计：JavaSE-任务101
08-08
面向对象程序设计：JavaSE-任务101
java中递归的应用，题目：f(20)=1,f(21)=4,f(n+2)=2*f(n+1)+f(n); 其中，n是大于零的整数，求f(10)的值。
qq_43193797的博客
02-20 3741
public class Test {     public static int f(int n){         if(n==20){             return 1;         }else if(n==21){             return 4;         }else if(n&lt;20){             return f(n+2)...
Java（八）
二锅头的博客
07-08 119
知识点1：可变形参的方法（jdk5.0新特性） package com.atguigu.java; /** * * * 测试java中方法的可变形参的使用（jdk5.0的新特性） * * 1. 可变形参的格式：数据类型 ... 参数名 * 2. 在调用可变形参的方式时，可以给可变形参赋值的参数个数为：0个，1个，2个,.... * 3. 可变形参的方法与同一个类中，相同方法名的多个方法间构成重载。（除了第4点中的情况） * 4. 可变形参的方法a与 参数同类型的数组的形参的方法b 不能在
java中的递归
xiaotai1234的博客
07-08 467
java中的递归 1.概述 递归方法：一个方法体内调用它自身。 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。 //计算1-100之间所有自然数的和 public int sum(int num){ if(num == 1){ return 1; }else{ return num + sum(num - 1); } } 2.练习 请用Java写出递归求阶乘(n!)的算法 已知有一个数列
JavaSE-11 什么是面向对象
擦镜子的默
07-20 120
Java的核心思想就是面向对象 面向对象编程（Object-Oriented Programming，OOP） 面向对象的本质是：以类的方式组织代码，以对象的方式组织（封装）数据 面向对象的三大特性： 封装 继承 多态 面向过程 VS 面向对象 面向过程： 一步一步执行，步骤清晰，第一步做什么，第二步做什么 … 面向过程适合处理一些较为简单的问题 面向对象： 物以类聚，分类思想，首先思考问题需要哪些分类，然后对这些分类进行单独思考，最后对某个分类下的细节进行面向过程的思索。 面向对象适合处.
JavaSE-03(IDEA面向对象的JavaSE项目)
Carson's Blog
09-12 569
面向对象思想概述 1. 概述 Java语言是一种面向对象的程序设计语言，而面向对象思想（OOP）是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。它区别于面向过程思想（POP），强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。 2. 面向对象与面向过程的区别 面向过程：
JavaSE-面向对象之类与对象
qq_59737375的博客
04-22 1300
权限控制符] class 类名 {//零个到多个构造器 * 构造器定义 * 注意:构造器无返回值类型[权限控制符] 类名(参数列表){};//零个到多个属性 * 属性定义[权限控制符] [static | final] 属性类型 属性名;//零个到多个方法 * 方法定义[权限控制符] [abstract | final] [static] 返回值类型 方法名(参数表){};提示：定义类的时候，不是必须显式写构造方法、属性、方法。【示例】：定义一个学生类。
JavaSE-面向对象
Destiny的博客
12-08 147
面向对象与面向过程 区别： 面向对象的程序设计具有更高的灵活性，便于程序的扩展和升级。面向过程主要是针对特定需求满足某业务条件下设计。 面向对象的三大特征 继承 封装 多态 ...
JavaSE部分-面向对象笔记
DYSLzx的博客
09-05 119
JavaSE部分-面向对象,个人笔记 针对名词 针对具体和抽象 封装,继承,多态(面向对象的三大特征) 抽象(面向对象的特殊使用) 一Java语言的特点 简单: 与常人的思维一致 跨平台(可移植) 多线程 完全面向对象 名词解释 类 : 对一个事物下一个抽象的概念 对象 : 一类事物中的一个具体实例 属性 : 用来描述事物的 方法 :事物所具备的功能(一般是动词) 类和对象都是由一组属性和方法组成的那么如何区分属性和方法? 名字后面没有小括号: 属性,有小括号:方法. 三 如何使用面向对线编程思
javaSE--面向对象--继承笔记
weixin_63443221的博客
06-19 60
当引用为null，没有引用地址指向堆里的对象时，即为nullpointexception--空指针异常
JavaSE-Day08 (面向对象)
qq_58293159的博客
06-22 110
面向对象必看
面向对象程序设计：JavaSE-任务11
08-08
面向对象程序设计：JavaSE-任务11
面向对象程序设计：JavaSE-任务81
08-08
面向对象程序设计：JavaSE-任务81
面向对象程序设计：JavaSE-任务21
08-08
面向对象程序设计：JavaSE-任务21
面向对象程序设计：JavaSE-任务91
08-08
(影响成绩评定)题目09_1在“任务03 类和对象（1） 题目03_1”中Student类的基础上，定义StudentManagementSystem类，用来封
java jar包如何运行或调用
NLP与推荐算法
05-08 264
java服务启动
jdk8新特性----Lambda表达式
最新发布
w_t_y_y的博客
05-11 294
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 352
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
jmeter分布式集群压测
u014694915的博客
05-07 577
目的：通过多台机器同时运行 性能压测 脚本，模拟更好的并发压力。
javase篇-第07讲--面向对象1
09-08
在JavaSE中，我们可以通过封装、继承和多态来实现面向对象编程的目标。封装可以提高程序的可维护性和可复用性，继承可以减少重复编码的工作量，多态可以灵活地操作对象。掌握这些基本概念和关键术语，可以帮助我们更...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值