第三章 类与对象

最新推荐文章于 2023-01-12 12:10:53 发布
最新推荐文章于 2023-01-12 12:10:53 发布
阅读量1.1k 收藏 3
点赞数 3
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ETF6996/article/details/52253103
版权

类

类可以看成是创建Java对象的模板。通过下面一个简单的类来理解下Java中类的定义：

public class Dog{
   String breed;
   int age;
   String color;
   void barking(){
   }

   void hungry(){
   }

   void sleeping(){
   }
}

一个类可以包含以下类型变量：

  • 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

  • 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

  • 类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

一个类可以拥有多个方法，在上面的例子中：barking()、hungry()和sleeping()都是Dog类的方法。

构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
下面是一个构造方法示例：

public class Puppy{
   public Puppy(){
   }

   public Puppy(String name){
      // 这个构造器仅有一个参数：name
   }
}

创建对象

对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：

  • 声明： 声明一个对象，包括对象名称和对象类型。
  • 实例化： 使用关键字new来创建一个对象。
  • 初始化： 使用new创建对象时，会调用构造方法初始化对象。

下面是一个创建对象的例子：

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("Passed Name is :" + name ); 
   }
   public static void main(String []args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

编译并运行上面的程序，会打印出下面的结果：

Passed Name is :tommy

访问实例变量和方法

通过已创建的对象来访问成员变量和成员方法，如下所示：

/* 实例化对象 */
ObjectReference = new Constructor();
/* 访问其中的变量 */
ObjectReference.variableName;
/* 访问类中的方法 */
ObjectReference.MethodName();

实例

下面的例子展示如何访问实例变量和调用成员方法：

public class Puppy{
   int puppyAge;
   public Puppy(String name){
      // 这个构造器仅有一个参数：name
      System.out.println("Passed Name is :" + name ); 
   }

   public void setAge( int age ){
       puppyAge = age;
   }

   public int getAge( ){
       System.out.println("Puppy's age is :" + puppyAge ); 
       return puppyAge;
   }

   public static void main(String []args){
      /* 创建对象 */
      Puppy myPuppy = new Puppy( "tommy" );
      /* 通过方法来设定age */
      myPuppy.setAge( 2 );
      /* 调用另一个方法获取age */
      myPuppy.getAge( );
      /*你也可以像下面这样访问成员变量 */
      System.out.println("Variable Value :" + myPuppy.puppyAge ); 
   }
}

编译并运行上面的程序，产生如下结果：

Passed Name is :tommy
Puppy’s age is :2
Variable Value :2

修饰符

Java语言提供了很多修饰符，主要分为以下两类：

  • 访问修饰符
  • 非访问修饰符

访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。
默认的，也称为 default，在同一包内可见，不使用任何修饰符。
私有的，以 private 修饰符指定，在同一类内可见。
共有的，以 public 修饰符指定，对所有类可见。
受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见。

默认访问修饰符-不使用任何关键字
使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为public static final,而接口里的方法默认情况下访问权限为public。

private，protected，public与C++中的一样，这里不再赘述

非访问修饰符

为了实现一些其他的功能，Java也提供了许多非访问修饰符。

static修饰符，用来创建类方法和类变量。
Final修饰符，用来修饰类、方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
Abstract修饰符，用来创建抽象类和抽象方法。
Synchronized和volatile修饰符，主要用于线程的编程。

Final修饰符

Final变量：

Final变量能被显式地初始化并且只能初始化一次。被声明为final的对象的引用不能指向不同的对象。但是final对象里的数据可以被改变。也就是说final对象的引用不能改变，但是里面的值可以改变。
Final修饰符通常和static修饰符一起使用来创建类常量。
实例:

public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";

  public void changeValue(){
     value = 12; //将输出一个错误
  }
}

Final方法：

类中的Final方法可以被子类继承，但是不能被子类修改。
声明final方法的主要目的是防止该方法的内容被修改。
如下所示，使用final修饰符声明方法。

public class Test{
    public final void changeName(){
       // 方法体
    }
}

Final类：

Final类不能被继承，没有类能够继承final类的任何特性。
实例：

public final class Test {
   // 类体
}

Abstract修饰符

抽象类：

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被abstract和final修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。
实例：

abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

抽象方法

抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。抽象方法不能被声明成final和strict。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法的声明以分号结尾，例如：public abstract sample();
实例：

public abstract class SuperClass{
    abstract void m(); //抽象方法
}

class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}

继承

  • 和C++不同，在Java中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类；

  • 继承中最常使用的两个关键字是extends和implements，这两个关键字的使用决定了一个对象和另一个对象是否是IS-A(是一个)关系。通过使用这两个关键字，我们能实现一个对象获取另一个对象的属性。

  • 所有Java的类均是由java.lang.Object类继承而来的，所以Object是所有类的祖先类，而除了Object外，所有类必须有一个父类。

通过过extends关键字可以申明一个类是继承另外一个类而来的，一般形式如下：

// A.java
public class A {
    private int i;
    protected int j;

    public void func() {

    }
}

// B.java
public class B extends A {   //类B继承于类A
}

以上的代码片段说明，B由A继承而来的，B是A的子类。而A是Object的子类，这里可以不显示地声明。
作为子类，B的实例拥有A所有的成员变量，但对于private的成员变量B却没有访问权限，这保障了A的封装性。

重写(Override)

重写是子类对父类的允许访问的方法的实现过程进行重新编写！返回值和形参都不能改变。即外壳不变，核心重写！
重写的好处在于子类可以根据需要，定义特定于自己的行为,也就是说子类能够根据需要实现父类的方法。
在面向对象原则里，重写意味着可以重写任何现有方法。实例如下：

class Animal{

   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{

   public void move(){
      System.out.println("狗可以跑和走");
   }
   public void bark(){
      System.out.println("狗可以吠叫");
   }
}

public class TestDog{

   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象

      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
      //b.bark();
   }
}

以上结果运行如下:

动物可以移动
狗可以跑和走

但是如果把上面代码中倒数第三行 b.bark()的注释隐掉，则该程序将抛出一个编译错误，因为b的引用类型Animal没有bark方法。

方法的重写规则：

  • 参数列表必须完全与被重写方法的相同；

  • 返回类型必须完全与被重写方法的返回类型相同；

  • 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected；

  • 父类的成员方法只能被它的子类重写；

  • 声明为final的方法不能被重写；

  • 声明为static的方法不能被重写，但是能够被再次声明；

  • 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法；

  • 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法；

  • 构造方法不能被重写；

  • 如果不能继承一个方法，则不能重写这个方法；

Super关键字

当需要在子类中调用父类的被重写方法时，要使用super关键字。

class Animal{

   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{

   public void move(){
      super.move(); // 应用super类的方法
      System.out.println("狗可以跑和走");
   }
}

public class TestDog{

   public static void main(String args[]){

      Animal b = new Dog(); // Dog 对象
      b.move(); //执行 Dog类的方法

   }
}

运行结果如下：

动物可以移动
狗可以跑和走

多态

多态存在的三个必要条件:

  • 继承
  • 重写
  • 父类引用指向子类对象

比如：

Parent p = new Child();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
以下是一个多态实例的演示，详细说明请看注释：

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法

      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 catchMouse
  }  

    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}

abstract class Animal {  
    abstract void eat();  
}  

class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  

class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

运行结果：

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

虚方法

上面谈到方法的重写，也就是子类能够重写父类的方法。
当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。
要想调用父类中被重写的方法，则必须使用关键字super（和C++不同）

/* 文件名 : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number) {
      System.out.println("Employee 构造函数");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public void mailCheck() {
      System.out.println("邮寄支票给： " + this.name
       + " " + this.address);
   }
   public String toString() {
      return name + " " + address + " " + number;
   }
   public String getName() {
      return name;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String newAddress) {
      address = newAddress;
   }
   public int getNumber() {
     return number;
   }
}

假设下面的Salary类继承上面的Employee类：

/* 文件名 : Salary.java */
public class Salary extends Employee
{
   private double salary; // 全年工资
   public Salary(String name, String address, int number, double salary) {
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck() {
       System.out.println("Salary 类的 mailCheck 方法 ");
       System.out.println("邮寄支票给：" + getName()
       + " ，工资为：" + salary);
   }
   public double getSalary() {
       return salary;
   }
   public void setSalary(double newSalary) {
       if(newSalary >= 0.0) {
          salary = newSalary;
       }
   }
   public double computePay() {
      System.out.println("计算工资，付给：" + getName());
      return salary/52;
   }
}

现在我们仔细阅读下面的代码，尝试给出它的输出结果：

/* 文件名 : VirtualDemo.java */
public class VirtualDemo {
   public static void main(String [] args) {
      Salary s = new Salary("员工 A", "北京", 3, 3600.00);
      Employee e = new Salary("员工 B", "上海", 2, 2400.00);
      System.out.println("使用 Salary 的引用调用 mailCheck -- ");
      s.mailCheck();
      System.out.println("使用 Employee 的引用调用 mailCheck--");
      e.mailCheck();
    }
}

以上实例编译运行结果如下：

Employee 构造函数
Employee 构造函数
使用 Salary 的引用调用 mailCheck –
Salary 类的 mailCheck 方法
邮寄支票给：员工 A ，工资为：3600.
使用 Employee 的引用调用 mailCheck–
Salary 类的 mailCheck 方法
邮寄支票给：员工 B ，工资为：2400.0

例子解析：

  • 实例中，实例化了两个 Salary 对象：一个使用 Salary 引用 s，另一个使用 Employee 引用 e

  • 当调用 s.mailCheck() 时，编译器在编译时发现 mailCheck() 在 Salary 类中，执行过程 JVM 就调用 Salary 类的 mailCheck()

  • 在调用s.mailCheck()时，Java虚拟机(JVM)调用Salary类的mailCheck()方法

  • 因为 e 是 Employee 的引用，所以调用 e 的 mailCheck() 方法时，编译器会去 Employee 类查找 mailCheck() 方法

  • 在编译的时候，编译器使用 Employee 类中的 mailCheck() 方法验证该语句， 但是在运行的时候，Java虚拟机(JVM)调用的是 Salary 类中的mailCheck()方法

以上整个过程被称为虚拟方法调用，该方法被称为虚拟方法。
Java中所有的方法都能以这种方式表现，因此，重写的方法能在运行时调用，不管编译的时候源代码中引用变量是什么数据类型。

接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在Java中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类相似点：

  • 一个接口可以有多个方法
  • 接口文件保存在.java结尾的文件中，文件名使用接口名

接口与类的区别：

  • 接口不能用于实例化对象
  • 接口没有构造方法
  • 接口中所有的方法必须是抽象方法
  • 接口不能包含成员变量，除了static和final变量
  • 接口不是被类继承了，而是要被类实现
  • 接口支持多重继承

接口的声明：

[可见度] interface 接口名称 [extends 其他的类名] {
        // 声明变量
        // 抽象方法
}

Interface关键字用来声明一个接口，下面是接口声明的一个简单例子：

/* 文件名 : NameOfInterface.java */
import java.lang.*;
//引入包

public interface NameOfInterface
{
   //任何类型 final, static 字段
   //抽象方法
}

接口有以下特性：

  • 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字
  • 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键子
  • 接口中的方法都是公有的

例如：

/* 文件名 : Animal.java */
interface Animal {

   public void eat();
   public void travel();
}

接口的实现
当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。
类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。
实现一个接口的语法，可以使用这个公式：

… implements 接口名称[, 其他接口, 其他接口…, …] …

实例：

/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{

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

   public void travel(){
      System.out.println("Mammal travels");
   } 

   public int noOfLegs(){
      return 0;
   }

   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

重写接口中声明的方法时，需要注意以下规则：

  • 类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常
  • 类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型
  • 如果实现接口的类是抽象类，那么就没必要实现该接口的方法

在实现接口的时候，也要注意一些规则：

  • 一个类可以同时实现多个接口
  • 一个类只能继承一个类，但是能实现多个接口
  • 一个接口能继承另一个接口，这和类之间的继承比较相似

接口的继承

一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。
下面的Sports接口被Hockey和Football接口继承：

// 文件名: Sports.java
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}

// 文件名: Football.java
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

// 文件名: Hockey.java
public interface Hockey extends Sports
{
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

Hockey接口自己声明了四个方法，从Sports接口继承了两个方法，这样，实现Hockey接口的类需要实现六个方法。
相似的，实现Football接口的类需要实现五个方法，其中两个来自于Sports接口。

接口的多重继承
在Java中，类的多重继承是不合法，但接口允许多重继承。
在接口的多重继承中extends关键字只需要使用一次，在其后跟着继承接口。 如下所示：

public interface Hockey extends Sports, Event

包（Package）

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间

包的作用

  • 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用
  • 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突
  • 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类

Java使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

包语句的语法格式为：

package pkg1[．pkg2[．pkg3…]];

例如,一个Something.java 文件它的内容

package net.java.util
public class Something{
   ...
}

一个包（package）可以定义为一组相互联系的类型（类、接口、枚举和注释），为这些类型提供访问保护和命名空间管理的功能。

以下是一些Java中的包：

  • java.lang-打包基础的类
  • java.io-包含输入输出功能的函数

创建包
创建package的时候，需要为这个package取一个合适的名字。之后，如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候，都必须将这个package的声明放在这个源文件的开头。
包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。
如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包（unnamed package）中。

例子
下面这个例子创建了一个叫做animals的包。通常使用小写的字母来命名避免与类、接口名字的冲突。
在animals包中加入一个接口（interface）：

/* 文件名: Animal.java */
package animals;

interface Animal {
   public void eat();
   public void travel();
}

接下来，在同一个包中加入该接口的实现：

package animals;

/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{

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

   public void travel(){
      System.out.println("Mammal travels");
   } 

   public int noOfLegs(){
      return 0;
   }

   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

然后，编译这两个文件，并把他们放在一个叫做animals的子目录中。 用下面的命令来运行：

$ mkdir animals
$ cp Animal.class  MammalInt.class animals
$ java animals/MammalInt
Mammal eats
Mammal travel

import关键字

为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用”import”语句可完成此功能。
在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：

import package1[.package2…].(classname|*);

如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。

例子

下面的payroll包已经包含了Employee类，接下来向payroll包中添加一个Boss类。Boss类引用Employee类的时候可以不用使用payroll前缀，Boss类的实例如下：

package payroll;

public class Boss
{
   public void payEmployee(Employee e)
   {
      e.mailCheck();
   }
}

如果Employee类不在payroll包中又会怎样？Boss类必须使用下面几种方法之一来引用其他包中的类
使用类全名描述，例如：

payroll.Employee

用import关键字引入，使用通配符”*”

import payroll.*;

使用import关键字引入Employee类

import payroll.Employee;

注意：
类文件中可以包含任意数量的import声明。import声明必须在包声明之后，类声明之前。

未完待续 。。。。。。

SIAT_啊哦
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
03_第3章 类与对象1
08-03
声明的变量和方法的参数被称作局部变量。1．变量的类型：成员变量和局部变量的类型可以是Java中的任何一种数据类型，包括基本类型：整型、浮点型、字符型；引用类型：
《Python语言程序设计》王恺 王志 李涛 机械工业出版社 第4章 面向对象 课后习题答案【强烈推荐】
于笨笨的博客
10-29 3068
点个????吧，秋梨膏！！！！！，建议收藏一波 第4章 面向对象 类和对象的关系即数据类型与变量的关系， 类 规定了可以用于存储什么数据，而 对象 用于实际存储数据，每个对象可存储不同的数据。 类中包含属性和方法。 属性 对应一个类可以用来保存哪些数据，而方法 对应一个类可以支持哪些操作（即数据处理）。 私有属性 ，是指在类内可以直接访问、而在类外无法直接访问的属性。 构造方法是Python类中的内置方法之一，它的方法名为__init__，在创建一个类对象时会自动执行，负责完成新创建对象
JAVA面向对象
m0_59564690的博客
01-12 267
java类和对象
Java对象和类知识点归纳&常见疑问
weixin_63289399的博客
03-22 646
对象：对象是类的一个实例，有状态和行为。 类：类是一个模板，它描述一类对象的行为和状态。 Java中的对象 软件对象有状态和行为。软件对象的状态就是属性，行为通过方法体现。 在软件开发中，方法操作对象内部状态的改变，对象的相互调用也是通过方法来完成。 Java 中的类 类可以看成是创建 Java 对象的模板。 创建一个简单的类来理解下 Java 中类的定义： public class Dog {String breed; int size; String colour; int age; v
Java继承 学习
gegejiawei的博客
07-22 302
思维导图 导学 在本章节内容中，我们将继续来学习面向对象三大特性之一的继承。之前的封装，实际上是针对一个类进行隐藏和访问控制操作，而即将要学习的继承，其实是在描述两个类之间的关系。 ...
java 入门学习
weixin_44071889的博客
05-17 214
Java 基础语法 一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。 类：类是一个模板，它描述一类对象的行为和状态。 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。 第一个J
第三章 类与对象.docx
08-08
java课程第三章：面向对象。摘要：面型对象的最初理解，类的封装，注释，成员访问控制说明，成员方法的使用，构造函数，this的使用，垃圾回收机制，static关键字的使用，枚举类型，类的组合。
C++语言程序设计教程：第3章 类与对象.ppt
06-14
C++语言程序设计教程：第3章 类与对象.ppt
第3章 类与对象.ppt
04-04
第3章 类与对象.ppt
Java程序设计课件：第三章 类与对象的深入理解.ppt
06-18
Java程序设计课件：第三章 类与对象的深入理解.ppt
ZIP压缩文件和已知明文攻击
qq_63811773的博客
12-26 3351
ZIP压缩文件和已知明文攻击
利用ARCHPR明文攻击对zip口令进行破解以及报错解决
热门推荐
weixin_43778378的博客
05-12 2万+
目录实验目的实验过程实验工具准备实验样本构造明文攻击实验应用实验总结 实验目的 利用已有的部分明文文件，通过APCHPR明文攻击，来破解包含该文件的加密压缩包。 实验过程 实验工具准备 所用破解工具为ARCHPR4.54： 实验样本构造 1.首先我们新建一个明文文件“明文.txt”，并用WinRAR压缩到“明文.zip”。（如果直接选择“发送到zip”，APCHPR可能会报“在选定的档案中没有匹配的文件”错。） 2.然后我们将“明文.txt”和一些其他文件（当然也可以没有）用WinRAR压缩到“加密的.z
zip明文攻击
啊哦的博客
02-03 1万+
所谓明文攻击就是已经通过其他手段知道zip加密文件中的某些内容，比如在某些网站上发现它的readme.txt文件，或者其他文件，这时就可以尝试破解了，例如我今天刚做了一个明文攻击的小题目： 源文件是：明文攻击.zip,但是一看发现zip文件里面有一个之前看到过的hash.exe，和一些其他加密文件，所以就将已经拥有的hash.exe压缩成zip，注意打包完成后，需要确认二者采用的压缩算法相同。一个简
JAVA进阶学习-java对象和类
xqsy2008的专栏
03-17 867
注：以下内容均参考http://www.w3cschool.cc/java Java对象和类 Java作为一种面向对象语言。支持以下基本概念： 多态继承封装抽象类对象实例方法消息解析 本节我们重点研究对象和类的概念。 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。类
java final 构造方法
qq_39642372的博客
09-23 1953
final   变量能被显式地初始化并且只能初始化一次。被声明为final的对象的引用不能指向不同的对象。但是final对象里的数据可以被改变。也就是说final对象的引用不能改变，但里面的值可以改变。 final方法可以被子类继承，但不能被子类修改。 final类不能被继承。 非访问控制修饰符 : final, abstract, strictfp String inpu
具体的一个实例，展示如何访问实例变量和调用成员方法
甜橙
11-08 2149
public class Puppy{     int puppyAge;     public Puppy(String name){         System.out.println("小狗的名字："+name);     }     public void setAge(int age){         puppyAge = age;     }     public
java 重载与重写
俊刚的博客
12-22 552
先来看下方法重载（Overloading）的定义：如果有两个方法的方法名相同，但参数不一致，哪么可以说一个方法是另一个方法的重载。重载Overloading是一个类中多态性的一种表现。 具体说明如下： 1.方法名相同 2.方法的参数类型，个数顺序至少有一项不同 3.方法的返回类型可以不相同 4.方法的修饰符可以不相同 5.main方法也可以被重载 实例： 通过重载 MainC
类、对象、方法、构造器及特性
hdughy的博客
09-01 285
类及类的成员 1、属性=成员变量=字段=域=instance 属性可以在创建类的对象后手动初始化也可以直接在定义时初始化也可以使用它的默认初始化值（默认初始化值同数组）； 2、方法=函数=method 类和类的对象的使用： 1、创建类：包括创建属性，方法，构造器等等； 2、实例化类=创建类的对象：new + 构造器； 3、通过类的对象来调用类的成员：“对象名.属性名”和“对象名.方法名”； ▲要深刻理解类，属性，方法调用之间的关系：要想调用一个方法/属性，只能通过该方法所在类的对象.
头哥java第四章类与对象二
最新发布
10-20
第四章类与对象二主要介绍了Java中类的继承、多态和抽象类等概念。具体内容包括： 1. 继承：子类可以继承父类的属性和方法，从而实现代码的复用。Java中使用关键字extends来实现继承。 2. 多态：同一种类型的对象...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值