Java面向对象从基础，进阶到高级

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

Java面向对象从基础，进阶到高级

面向对象概述：

  • 面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，是一种对现 实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。
  • 面向对象是相对于面向过程来讲的，指的是把 相关的数据和方法组织为一个整体 来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

面向过程到面向对象的思想转变：

  • 面向过程到面向对象，是程序员思想上 从执行者到指挥者的转变。
  • 面向过程关注的是执行的过程，面向对象关注的是具备功能的对象。

面向对象的三大思想和三大特征：

三大思想：

​ OOA：面向对象分析（Object Oriented Analysis）

​ OOD：面向对象设计（Object Oriented Design）

​ OOP：面向对象程序（Object Oriented Programming）

三大特征：

封装性：所有的内容对外部不可见

继承性：将其他的功能继承下来继续发展

多态性：方法的重载本身就是一个多态性的体现

1.面向对象基础

1.类与对象

类与对象的关系：

类表示一个共性的产物，是一个综合的特征，而对象，是一个个性的产物，是一个个体的特征。（类似生活中的图纸与实物的概念。）

类必须通过对象才可以使用，对象的所有操作都在类中定义。

类由属性和方法组成：

· 属性：就相当于人的一个个的特征

· 方法：就相当于人的一个个的行为，例如：说话、吃饭、唱歌、睡觉

类与对象的创建和格式：

类的定义格式 ：

class 类名称{   
    成员属性 //属性定义格式： 数据类型 属性名; 
            //属性定义并赋值的格式： 数据类型 属性名 = 初始化值;
    成员方法 /**方法定义格式： 
            权限修饰符 返回值类型 方法名(形式参数列表){ 
                 方法体 
                 return 返回值； 
            }*/
}

对象的创建：

  • 一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下:

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

  • 如果要想访问类中的属性或方法（方法的定义），则可以依靠以下的语法形式：

​ 访问类中的属性： 对象.属性 ;

​ 调用类中的方法： 对象.方法(实际参数列表) ;

2.创建对象内存分析

2.1栈：存储基本数据类型的数据以及引用数据类型的引用

特点：
先进后出；Java栈的区域很小 , 大概2m左右 , 存取的速度特别快 。

存储速度快的原因:

1.栈内存, 通过 ‘栈指针’ 来创建空间与释放空间 !

2.指针向下移动, 会创建新的内存, 向上移动, 会释放这些内存 !

3.这种方式速度特别快 , 仅次于PC寄存器 !

但是这种移动的方式, 必须要明确移动的大小与范围 , 明确大小与范围是为了方便指针的移动 , 这是一个对于数据存储的限制, 存储的数据大小是固定的 , 影响了程序的灵活性 ！所以我们把更大部分的数据 存储到了堆内存中 。

例如: int a =10;

​ Person p = new Person();

10存储在栈内存中 , 第二句代码创建的对象的引用 p存在栈内存中

本地方法栈 ：保存本地(native)方法的地址 !

2.2堆：存放类的对象

Java是一个纯面向对象语言, 限制了对象的创建方式；所有类的对象都是通过new关键字创建。

new关键字： 是指告诉JVM , 需要明确的去创建一个新的对象 , 去开辟一块新的堆内存空间。

优点：
我们创建对象时 , 不必关注堆内存中需要开辟多少存储空间 , 也不需要关注内存占用时长。

GC回收堆内存的规则: 当栈内存中不存在此对象的引用时,则视其为垃圾 , 等待垃圾回收器回收 。

例如:

Person p0 = new Person();

Person p1 = p0;

Person p2 = new Person();

2.3方法区

存放的是：- 类信息 - 静态的变量 - 常量 - 成员方法

方法区中包含了一个特殊的区域 ( 常量池 )(存储的是使用static修饰的成员)

2.4PC寄存器

PC寄存器保存的是 当前正在执行的 JVM指令的 地址 ! 在Java程序中, 每个线程启动时, 都会创建一个PC寄存器 !

3.方法的使用方式

3.1构造方法

例如:Person p = new Person(); 在右侧Person后面出现的小括号, 其实就是在调用构造方法 !

构造方法概述：

作用：用于对象初始化。

执行时机：在创建对象时,自动调用

特点：所有的Java类中都会至少存在一个构造方法 ；如果一个类中没有明确的编写构造方法, 则编译器会自动生成一个无参的构造方法, 构造方法中没有任何的代码！如果自行编写了任意一个构造器, 则编译器不会再自动生成无参的构造方法。

定义格式：

定义的格式: 与普通方法基本相同, 区别在于: 方法名称必须与类名相同, 没有返回值类型的声明 !

案例：

public class Demo3{ 
     public static void main(String[] args){ 
          Person p = new Person(); 
          p = new Person(); 
          p = new Person(); 
          p = new Person(); 
     } 
}
class Person{ 
    public Person(){ 
         System.out.println("对象创建时,此方法调用"); 
    }      
}

注意：1.当类中有非常量成员变量时，建议提供两个版本的构造方法，一个是无参构造方法，一个是全属性做参数的构造方法。 2.当类中所有成员变量都是常量或者没有成员变量时，建议不提供任何版本的构造。

3.2方法的重载
  • 方法名称相同, 参数类型或参数长度不同, 可以完成方法的重载 ! 方法的重载与返回值无关!

​ 方法的重载 ,可以让我们在不同的需求下, 通过传递不同的参数调用方法来完成具体的功能。

  • 一个类, 可以存在多个构造方法 : 参数列表的长度或类型不同即可完成构造方法的重载 ~

​ 构造方法的重载 ,可以让我们在不同的创建对象的需求下, 调用不同的方法来完成对象的初始化!

2.面向对象进阶

1.封装（private）

我们观察如下代码：

class Person{ 
      private String name ; // 表示姓名 
      private int age ; // 表示年龄 
      void tell(){ 
           System.out.println("姓名：" + name + "；年龄：" + age) ; 
      } 
}
public class Demo{ 
     public static void main(String args[]){ 
           Person per = new Person() ; 
           per.name = "张三" ; 
           per.age = -30 ; 
           per.tell() ; 
     } 
};

以上的操作代码并没有出现了语法错误，但是出现了逻辑错误 （年龄-30岁）

在开发中, 为了避免出现逻辑错误,我们建议对所有属性进行封装,并为其提供setter及getter方法进行设置和取得操作。

修改代码如下：

class Person{ 
     private String name ; // 表示姓名 
     private int age ; // 表示年龄 
     void tell(){ 
         System.out.println("姓名：" + getName() + "；年龄：" + getAge()) ; 
     }
     public void setName(String str){ 
           name = str ; 
     }
     public void setAge(int a){ 
           if(a>0&&a<150) 
           age = a ; 
     }
     public String getName(){ 
           return name ; 
     }
     public int getAge(){ 
     return age ; 
     } 
}
public class OODemo10{ 
     public static void main(String args[]){ 
           Person per = new Person() ;
           per.setName("张三") ; 
           per.setAge(-30) ; 
           per.tell() ; 
     } 
}

2.this

在Java基础中，this关键字是一个最重要的概念。使用this关键字可以完成以下的操作：

· 调用类中的属性

· 调用类中的方法或构造方法

· 表示当前对象

例如：

package practice2;
public class Demo3 {
	public static void main(String[] args) {
		Person3 P1 = new Person3("张三",18);
		Person3 p2 = new Person3("李四",10);		
		P1.say();
		p2.say();
		Person3 p3 = new Person3();
		p3.say();
	}
}
//this指的是当前对象
class Person3 {
	private String name;
	private int age;
	//在一个构造方法中，使用另一个构造方法时，调用的代码必须编写在方法的第一行
	Person3() {
		this("王五", 16);
	}
	// this一直存在，只是被隐藏
	Person3(String name,int age) {
		this.name = name;
		this.age = age;
	}
	void say() {
		System.out.println("姓名:"+name+",年龄:"+age);
	}
}

3.静态（statics）

概述：

static表示“静态”的意思，可以用来修饰成员变量和成员方法(还有静态代码块和静态内部类)。

static的主要作用在于创建独立于具体对象的域变量或者方法

简单理解：被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。 并且不会因为对象的多次创建 而在内存中建立多份数据 。

重点：

  1. 静态成员 在类加载时加载并初始化。

  2. 无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )

  3. 在访问时： 静态不能访问非静态 , 非静态可以访问静态 !

4.代码块

普通代码块 ：
在执行的流程中出现的代码块， 我们称其为普通代码块。

构造代码块 ：
在类中的成员代码块， 我们称其为构造代码块， 在每次对象创建时执行， 执行在构造方法之前。

静态代码块 ：
在类中使用static修饰的成员代码块， 我们称其为静态代码块， 在类加载时执行。 每次程序启动到关闭 ，只会执行一次的代码块。

同步代码块 ：
在后续多线程技术中学习。

注意：构造方法 与 构造代码块 以及 静态代码块的执行顺序：静态代码块 --> 构造代码块 --> 构造方法

例如：

package practice2;
public class Demo5 {
	public static void main(String[] args) {
		/**
		 * 编写在顺序执行的代码流程中的代码块
		 */
		{
			//int age = 18;
			//System.out.println(age);
		}
		Person5 p1 = new Person5();
		Person5 p2 = new Person5();
	}
}
class Person5{
	private int age;
	private String name;
	/*
	 * 构造代码块，随着对象的每次创建，执行一次，且执行在构造方法之前
	 * 区别于构造方法的是：
	 *    无论用户调用哪一个构造方法来创建对象，构造代码块都必然会执行
	 */
	{
		System.out.println("构造代码块执行");
	}
	/*
	 * 静态代码块，随着类的加载而加载（第一次使用）
	 * 因为类只加载一次，所以静态代码块也只执行一次
	 */
	static {
		System.out.println("静态代码块执行");
	}
	public Person5() {
		System.out.println("对象创建时执行2");
	}
	public Person5(String name) {
		System.out.println("对象创建时执行2");
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

5.包

介绍：

1.把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。

2.包如同文件夹一样，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。

3.包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

使用规则：

1.包中java文件的定义：在.java文件的首部， 必须编写类所属哪个包。格式：package 包名;

2.包名通常由多个单词组成， 所有单词的字母小写， 单词与单词之间使用.隔开 ，一般命名为“com.公司名.项目名.模块名…”。

6.权限修饰符

修饰符类包子类其他包
public√√√√
protected√√√×
default√√××
private√×××

3.面向对象高级

1.抽象类

概念：抽象类必须使用abstract class声明，一个抽象类中可以没有抽象方法。抽象方法必须写在抽象类或者接口中。

格式：
abstract class 类名{ 
        // 抽象类             
        } 
抽象方法：只声明而未实现的方法称为抽象方法（未实现指的是：没有“{}”方法体），抽象方法必须使用abstract关键字声明。 
格式：
abstract class 类名{ // 抽象类 
public abstract void 方法名() ;    // 抽象方法，只声明而未实现 
}

注意：

  1. 抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。
  2. 一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写(重写)抽象类中的全部抽象方法。

常见问题：

1、 抽象类能否使用final声明？

不能，因为final属修饰的类是不能有子类的 ， 而抽象类必须有子类才有意义，所以不能。

2、 抽象类能否有构造方法？

能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默认是无参的），之后再调用子类自己的构造方法。

2.接口

概念：如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。

定义格式： interface 接口名称{ 
          全局常量 ; //全局常量编写时， 可以省略public static final 关键字，
                    //例如： public static final String INFO = "内容" ; 简写后： String INFO = "内容" ;
          抽象方法 ; //抽象方法编写时， 可以省略 public abstract 关键字， 
                    //例如： public abstract void print() ; 简写后： void print() ;
          }

优点：
1、 降低程序的耦合性

​ 2、 易于程序的扩展

​ 3、 有利于程序的维护

接口的实现 implements:

接口可以多实现：

格式：class 子类 implements 父接口1,父接口2…{

​ }

以上的代码称为接口的实现。那么如果一个类即要实现接口，又要继承抽象类的话，则按照以下的格式编写即可：

class 子类 extends 父类 implements 父接口1,父接口2…{

}

接口的继承:
接口因为都是抽象部分， 不存在具体的实现， 所以允许多继承,例如：

interface C extends A,B{

}

注意：如果一个接口要想使用，就必须依靠子类。 子类（如果不是抽象类的话）要实现接口中的所有抽象。

接口和抽象类的区别：

1、抽象类要被子类继承，接口要被类实现。

2、接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法。

3、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

4、抽象类使用继承来使用， 无法多继承。 接口使用实现来使用， 可以多实现。

5、抽象类中可以包含static方法 ，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明静态方法）。

6、接口不能有构造方法，但是抽象类可以有。

3.多态

概念：
多态就是对象的多种表现形式（多种体现形态）；**实现方式：**重写；接口；抽象类和抽象方法。

对象的多态性，从概念上非常好理解，在类中有子类和父类之分，子类就是父类的一种形态 ，对象多态性就从此而来。

ps: 方法的重载 和 重写 也是多态的一种， 不过是方法的多态（相同方法名的多种形态）。

重载： 一个类中方法的多态性体现

重写： 子父类中方法的多态性体现。

多态的使用：对象的类型转换

类似于基本数据类型的转换：
1.向上转型：将子类实例变为父类实例
格式：父类 父类对象 = 子类实例 ；
​2.向下转型：将父类实例变为子类实例
格式：子类 子类对象 = （子类）父类实例 ；

Java中重载（overload）和重写（override）的区别：

  1. 发生的位置：重载：一个类中，重写：子父类中

  2. 参数列表限制：重载：必须不同，重写：必须相同

  3. 返回值类型：重载：与返回值类型无关，重写：返回值类型必须一致

  4. 访问权限：重载：与访问权限无关，重写：子类方法权限必须不能小于父类权限

  5. 异常处理：重载：与异常无关，重写：异常范围可以减少，但是不能抛出新的异常

4.instanceof

作用：判断某个对象是否是指定类的实例，则可以使用instanceof关键字

格式：实例化对象 instanceof 类 //此操作返回boolean类型的数据

5.object类

概念：

Object类是所有类的父类（基类），如果一个类没有明确的继承某一个具体的类，则将默认继承Object类。

例如我们定义一个类： public class Person{ }

其实它被使用时 是这样的： public class Person extends Object{ }

Object的多态：
使用Object可以接收任意的引用数据类型 。

to String：
建议重写Object中的toString方法。 此方法的作用：返回对象的字符串表示形式。Object的toString方法， 返回对象的内存地址 。

equals：
建议重写Object中的equals(Object obj)方法，此方法的作用：指示某个其他对象是否“等于”此对象。

Object的equals方法：实现了对象上最具区别的可能等价关系; 也就是说，对于任何非空引用值x和y ，当且仅当x和y引用同一对象（ x == y具有值true ）时，此方法返回true 。

equals方法重写时的五个特性：

自反性 ：对于任何非空的参考值x ， x.equals(x)应该返回true 。

对称性 ：对于任何非空引用值x和y ， x.equals(y)应该返回true当且仅当y.equals(x)回报true 。

传递性 ：对于任何非空引用值x ,y和z ，如果x.equals(y)回报true个y.equals(z)回报true，然后x.equals(z)应该返回true 。

一致性 ：对于任何非空引用值x和y ，多次调用x.equals(y)始终返回true或始终返回false ，前提是未修改对象上的equals比较中使用的信息。

非空性 ：对于任何非空的参考值x ， x.equals(null)应该返回false 。

6.内部类

概念：
在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：

1、成员内部类 ：

成员内部类是最普通的内部类，它的定义为位于另一个类的内部，形如下面的形式：

class Outer { 
    private double x = 0; 
    public Outer(double x) { 
        this.x = x; 
    }class Inner { //内部类 
        public void say() { 
            System.out.println("x="+x); 
        } 
    } 
}

特点： 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量
外部类.this.成员方法
外部使用成员内部类
Outter outter = new Outter();
Outter.Inner inner = outter.new Inner();

2、局部内部类 ：

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限

于方法内或者该作用域内。

例如：

class Person{ 
    public Person() {
    } 
}
class Man{ 
    public Man(){
    }
    public People getPerson(){
        class Student extends People{ //局部内部类 
            int age =0; 
        }
        return new Student(); 
    } 
}

注意:局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

3、匿名内部类 ：

匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。创建格式如下：

new 父类构造器（参数列表）|实现接口（）

{

//匿名内部类的类体部分

}

在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。

注意：

1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。

2、匿名内部类中是不能定义构造函数的。

3、匿名内部类中不能存在任何的静态成员变量和静态方法。

4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

6、只能访问final型的局部变量 。

4、静态内部类 ：

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。

静态内部类是不需要依赖于外部类对象的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法。

格式：

public class Test {
    public static void main(String[] args) { 
        Outter.Inner inner = new Outter.Inner(); 
    } 
}
class Outter {
    public Outter() {
    }
    static class Inner { 
        public Inner() { 
        } 
    } 
}

7.包装类

概念：

在Java中有一个设计的原则“一切皆对象”，那么这样一来Java中的一些基本的数据类型，就完全不符合于这种设计思想，因为Java中的八种基本数据类型并不是引用数据类型，所以Java中为了解决这样的问题，引入了八种基本数据类型的包装类。

序号基本数据类型包装类
1intInteger
2charCharacter
3floatFloat
4doubleDouble
5booleanBoolean
6byteByte
7shortShort
8longLong

以上的八种包装类，可以将基本数据类型按照类的形式进行操作。但是，以上的八种包装类也是分为两种大的类型的：

Number：Integer、Short、Long、Double、Float、Byte都是Number的子类表示是一个数字。

Object：Character、Boolean都是Object的直接子类。

装箱和拆箱操作：

以下以Integer和Float为例进行操作 ：

将一个基本数据类型变为包装类，那么这样的操作称为装箱操作。

将一个包装类变为一个基本数据类型，这样的操作称为拆箱操作。

装箱操作： 
在JDK1.4之前 ，如果要想装箱，直接使用各个包装类的构造方法即可，例如： 
    int temp = 10 ; // 基本数据类型 
    Integer x = new Integer(temp) ; // 将基本数据类型变为包装类 
在JDK1.5，Java新增了自动装箱和自动拆箱，而且可以直接通过包装类进行四则运算和自增自建操作。例如： 
    Float f = 10.3f ; // 自动装箱 
    float x = f ; // 自动拆箱 
    System.out.println(f * f) ; // 直接利用包装类完成 
    System.out.println(x * x) ; // 直接利用包装类完成

因为所有的数值型的包装类都是Number的子类，Number的类中定义了如下的操作方法，以下的全部方法都是进行拆箱的操作。

序号方法描述
1public byte byteValue()用于Byte->byte
2public abstract double doubleValue()用于Double->double
3public abstract float flfloatValue()用于Float->flfloat
4public abstract int intValue()用于Integer->int
5public abstract long longValue()用于Long->long
6public short shortValue()用于Short->short
字符串转换：

使用包装类还有一个很优秀的地方在于：可以将一个字符串变为指定的基本数据类型，此点一般在接收输入数据上使用较多。

在Integer类中提供了以下的操作方法：

public static int parseInt(String s) ：将String变为int型数据

在Float类中提供了以下的操作方法：

public static float parseFloat(String s) ：将String变为Float

在Boolean 类中提供了以下操作方法：

public static boolean parseBoolean(String s) ：将String变为boolean

…

8.可变参数

一个方法中定义完了参数，则在调用的时候必须传入与其一一对应的参数，但是在JDK 1.5之后提供了新的功能，可以根据需要自动传入任意个数的参数。

语法：

返回值类型 方法名称(数据类型…参数名称){

//参数在方法内部 ， 以数组的形式来接收

}

注意：可变参数只能出现在参数列表的最后

字符串转换：

使用包装类还有一个很优秀的地方在于：可以将一个字符串变为指定的基本数据类型，此点一般在接收输入数据上使用较多。

在Integer类中提供了以下的操作方法：

public static int parseInt(String s) ：将String变为int型数据

在Float类中提供了以下的操作方法：

public static float parseFloat(String s) ：将String变为Float

在Boolean 类中提供了以下操作方法：

public static boolean parseBoolean(String s) ：将String变为boolean

…

8.可变参数

一个方法中定义完了参数，则在调用的时候必须传入与其一一对应的参数，但是在JDK 1.5之后提供了新的功能，可以根据需要自动传入任意个数的参数。

语法：

返回值类型 方法名称(数据类型…参数名称){

//参数在方法内部 ， 以数组的形式来接收

}

注意：可变参数只能出现在参数列表的最后

9.递归

递归，在数学与计算机科学中，是指在方法的定义中使用方法自身。也就是说，递归算法是一种直接或者间接调用自身方法的算法。
递归流程图如下：
在这里插入图片描述

简约的幻想
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java面向对象浅谈——面向对象三大特征：封装、继承、多态
Meqtix的博客
09-03 266
面向对象高级继承继承格式子类实例化内存分析super详解重写（Override）重写（Override）规则重写（Override）与重载（Overload）的区别final关键字作用抽象类概念格式抽象方法不能被实例化常见问题抽象类和普通类的区别接口概念面向接口编程思想全局常量和抽象方法的简写接口的实现 implements接口的继承注意接口和抽象类的区别 继承 继承是Java面对对象很重要的一部分，给类进行等级层次的划分，即分为父类和子类，父类拥有的特征和行为，能被子类继承。 继承格式 class 子类
Java基础-面向对象进阶
m0_65246653的博客
07-06 183
面向对象进阶
java面向接口编程
01-08
面向接口编程的例子，生活中的实例来说明接口的概念，对理解java接口有很大帮助！
Java学习 --- 面向对象之多态
qq_46093575的博客
09-12 214
方法或对象具有多种形态，是面向对象的三大特征之一，多态是建立在封装和继承之上的。
java静态成员变量静态方法 和普通成员变量 普通方法存在JVM哪个区域
豆恭梓的博客
06-25 2478
方法区是一块用于存储类的结构信息、静态变量、常量、编译后的代码等的内存区域。普通方法的字节码被加载到方法区中，但方法的执行是在栈内存中进行的。每个线程都有自己的栈，栈中包含了方法的调用栈帧，用于存储局部变量和方法调用的相关信息。需要注意的是，静态成员变量和静态方法的生命周期与类的生命周期一致，而普通成员变量和普通方法的生命周期与对象实例的生命周期相关。Java静态成员变量和静态方法以及普通成员变量和普通方法在JVM中存在不同的区域。普通成员变量和普通方法存储在堆内存（Heap）和栈内存（Stack）中。
由static修饰的成员变量和成员方法
m0_67683346的博客
05-11 4125
目录 一、static修饰的成员变量 1、变量的创建 2、静态成员变量在内存中的存储 3、静态成员变量的访问 4、静态成员变量的生命周期 5、静态成员变量的特点总结 二、static修饰的成员方法 1、认识 2、总结 一、static修饰的成员变量 1、变量的创建 static修饰的成员变量称为静态成员变量，也称为类变量，它不属于某一个对象，而是由所有对象共享的。 举例： 我们先创建一个学生类类型，再new三个学生对象，每个学生的姓名、年龄、性别都是有所差异的，但是每个学生所
Java面向对象进阶
余独好修的博客
09-02 155
面向对象进阶 一、封装private 在开发中，为了避免出现逻辑错误，我们建议对所有属性进行封装，并为其提供setter及getter方法进行设置和取得操作。 意义： 保护或者防止代码（数据）被我们无意中破坏。 保护成员属性，不让类以外的程序直接访问和修改。 原则： 隐藏对象的属性和实现细节，仅对外公开访问方法，并且控制访问级别。 例如： 不封装： Person1 p = new Person1(); p.name = "张三"; //逻辑错误 年龄外界不能随便定义为负数 p.age = -100
面向对象进阶，高级进阶，萌新
06-05
面向对象进阶，高级进阶，萌新
Java面向对象实战进阶
06-19
本教程是在课程“Java面向对象开发基础”的基础上的进阶部分，java基础课程部分免费。主要包括Java高级编程部分，包括：Java修饰符、抽象类和接口编程、Java常用类、集合、异常、多线程开发、IO流和文件、Java网络...
Java面向对象的三大特性和面向对象的进阶
04-21
主要简述Java面向对象基础，进阶，高级；从封装、继承、多态、接口、内部类、抽象类和代码块 适合刚开始的新手参考，毕竟我也是自学的 主要可以使用在计算机刚入门的小伙伴或者回来看一看复习一下简单的基础的 ① 凡...
搞定JAVA基础面向对象视频课程下载整理.zip
08-21
Java是一种广泛使用的高级编程语言，尤其在企业级应用开发领域占据主导地位。...通过这个"搞定JAVA基础面向对象"视频课程，学习者将有机会系统地学习Java编程，为进一步的进阶学习和实际项目开发打下坚实的基础。
java基础 Java开发入门到精通PPT课件 共353页.ppt
12-19
Java的基础知识包括语法基础、面向对象编程以及高级编程接口，这些内容构成了Java开发入门到精通的核心。 **Java语法基础**是学习Java的第一步，涵盖了变量、数据类型、运算符、控制流（如if语句、for循环、while...
throw new Exception是什么意思，这么使用
sinat_32823207的博客
08-12 1万+
throw new Exception(“自己写bai的抛出错误的原因”). 用这句的是原因，我们已经知道有一个错误存在，然后用这个抛出错误的原因让使用这个代码的人知道这是为什么，这一般是做基础部分的人用的。 比较: public doube 除法(double a,double b) { if(b==0) { throw new Exception("除数不能为0"); } return a/b; } 然后是别的程序员使用你的这段代码进行其他的开发，然后他们在测试的时候，是这么调用的除法(3，0），编译
Java中的异常（Exception）
AAAAA_9的博客
11-25 1973
Java中的异常Exception，分为编译时异常和运行时异常
throw和throw ex的区别
weixin_30624825的博客
03-25 424
原文地址：http://www.cnblogs.com/JerryTian/archive/2012/09/24/2699459.html 之前，在使用异常捕获语句try...catch...throw语句时，一直没太留意几种用法的区别，前几天调试程序时无意中了解到几种使用方法是有区别的，网上一查，还真是，主要是区别在堆栈信息的起始点不同。总结如下： 我们都知道，C#中使用throw和thro...
java中的throw new Exception();和throw e;异常抛出
热门推荐
探索者_wmc的博客
02-27 7万+
java代码如下： package com.imooc.exception; public class Throw1 {     public static void main(String[] args) {         // TODO Auto-generated method stub         Throw1 test = new Throw1();    
Java 面向接口编程
TheAnnoyingDog的博客
03-23 3445
面向接口编程 接口介绍 接口 (interface) ，用来描述一个类应该做什么，而不指定它们的具体逻辑。 举一个生活中的例子，比如说一部手机。我们可以定义一个"手机"接口标准，例如充电器要使用TYPE-C，安卓系统以及大小尺寸等，然后各大手机厂商就按照这个标准来生产手机，有一天手机坏掉了，但是充电器还是好的，那么我们把换个手机就可以还使用原来的充电器充电了。 在Java中的接口也是一样，接口不是类，而是对希望符合这个接口的类的一组需求。在代码设计中，我们事先约定好项目的各个功能的接口（接口的签名和方法），
在catch块中throw new Exception的意义 .
blueling51的专栏
11-28 4752
throw new Exception(String, Exception) throw new Exception(String) throw是明确地抛出异常 MSDN:Exception (String, Exception) 使用指定错误信息和对作为此异常原因的内部异常的引用来初始化 Exception 类的新实例。     在发现异常以后作一下记录异常信息然后在抛出异常，让
Java-Lambda
最新发布
lizhiwei21的博客
07-21 178
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java面向对象开发：从基础到实战
学生需要严格遵守上课纪律，积极参与讨论，课前预习，以充分理解和掌握Java面向对象编程技术。 通过这个课程，学生不仅能够理解面向对象编程的核心概念，还能熟练使用Java语言进行软件开发，为未来在IT领域进行项目...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值