Java基础17-java对象和类

java对象和类

一、类二、构造方法三、创建对象四、访问实例变量和方法五、源文件声明规则内部类01、非静态内部类02、私有的内部类03、静态内部类04、从内部类访问外部类成员 匿名类01、匿名类继承一个父类02、匿名类实现一个接口 六、Java 包import 语句 Java作为一种面向对象语言。支持以下基本概念：多态、继承、封装、抽象、类、对象、实例、方法、重载

一、类

对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。对象：实体，看得见摸得着 类：类是一个模板，它描述一类对象的行为和状态。抽象，共同特征的实体组成一个类，java最小单位。类名更改：refactor

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

public class Dog{ String breed; int age; String color; void barking(){ } void hungry(){ } void sleeping(){ } } Dog xh； xh.hi("xiaozhu")；//报空指针异常nullPointerException，没有new对象 Dog xh=new Dog（）； xh.hi("xiaozhu")；//正确

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

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。 成员变量（属性）：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。 类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。 属性在整个class中，若要调用属性，可以用this.属性名（this是当前对象的意思，this.一定是属性值） 方法中局部变量可以跟属性同名，在方法中就近原则使用局部变量

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

二、构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。 在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，无返回值，给类中属性赋初值，一个类可以有多个构造方法。 在new对象的同时运行，不需要在main方法赋值

Java规定每个类必须有构造方法，创建子类时，会先调用父类的默认构造方法。如果没有构造方法，系统默认会送一个构造方法； 如果系统发现构造了构造方法，就不送默认构造，构造了构造方法，用super（参数），手动调用父类构造。 super（）：调用父类的构造方法 super.eat()：用父类的eat（）方法

有参数的构造方法 public Dog(String name,String color) { System.out.println("生小狗"); this.name=name; this.color=color; } 无参数的构造方法 public Dog() { System.out.println("无参数构造方法"); } 构造方法的调用 Dog dog=new Dog("小黑","黑色"); dog.hi1(); //构造方法调用1 Dog dog=new Dog();

三、创建对象

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

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

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

四、访问实例变量和方法

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

public class Puppy{ int puppyAge; public Puppy(String name){ // 这个构造器仅有一个参数：name System.out.println("小狗的名字是 : " + name ); } public void setAge( int age ){ puppyAge = age; } public int getAge( ){ System.out.println("小狗的年龄为 : " + puppyAge ); return puppyAge; } public static void main(String[] args){ /* 创建对象 */ Puppy myPuppy = new Puppy( "tommy" ); /* 通过方法来设定age */ myPuppy.setAge( 2 ); /* 调用另一个方法获取age */ myPuppy.getAge( ); /*你也可以像下面这样访问成员变量 */ System.out.println("变量值 : " + myPuppy.puppyAge ); } }

五、源文件声明规则

当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

一个源文件中只能有一个 public 类 一个源文件可以有多个非 public 类 源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。 如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。 如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。 import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

类有若干种访问级别，并且类也分不同的类型：抽象类和 final 类等。 除了上面提到的几种类型，Java 还有一些特殊的类，如：内部类、匿名类。

内部类

Java 一个类中可以嵌套另外一个类，语法格式如下：

class OuterClass { // 外部类 // ... class NestedClass { // 嵌套类，或称为内部类 // ... } }

要访问内部类，可以通过创建外部类的对象，然后创建内部类的对象来实现。

嵌套类有两种类型： 非静态内部类 静态内部类

01、非静态内部类

非静态内部类是一个类中嵌套着另外一个类。 它有访问外部类成员的权限， 通常被称为内部类。 由于内部类嵌套在外部类中，因此必须首先实例化外部类，然后创建内部类的对象来实现。

class OuterClass { int x = 10; class InnerClass { int y = 5; } } public class MyMainClass { public static void main(String[] args) { OuterClass myOuter = new OuterClass(); OuterClass.InnerClass myInner = myOuter.new InnerClass(); System.out.println(myInner.y + myOuter.x); } }

02、私有的内部类

内部类可以使用 private 或 protected 来修饰，如果你不希望内部类被外部类访问可以使用 private 修饰符

class OuterClass { int x = 10; private class InnerClass { int y = 5; } } public class MyMainClass { public static void main(String[] args) { OuterClass myOuter = new OuterClass(); OuterClass.InnerClass myInner = myOuter.new InnerClass(); System.out.println(myInner.y + myOuter.x); } } 以上实例 InnerClass 设置为私有内部类，执行会报错

03、静态内部类

静态内部类可以使用 static 关键字定义，静态内部类我们不需要创建外部类来访问，可以直接访问它 注意：静态内部类无法访问外部类的成员。

class OuterClass { int x = 10; static class InnerClass { int y = 5; } } public class MyMainClass { public static void main(String[] args) { OuterClass.InnerClass myInner = new OuterClass.InnerClass(); System.out.println(myInner.y); } }

04、从内部类访问外部类成员

内部类一个高级的用法就是可以访问外部类的属性和方法：

class OuterClass { int x = 10; class InnerClass { public int myInnerMethod() { return x; } } } public class MyMainClass { public static void main(String[] args) { OuterClass myOuter = new OuterClass(); OuterClass.InnerClass myInner = myOuter.new InnerClass(); System.out.println(myInner.myInnerMethod()); } }

匿名类

Java 中可以实现一个类中包含另外一个类，且不需要提供任何的类名直接实例化。 主要是用于在我们需要的时候创建一个对象来执行特定的任务，可以使代码更加简洁。 匿名类是不能有名字的类，它们不能被引用，只能在创建时用 new 语句来声明它们。

匿名类语法格式：

class outerClass { // 定义一个匿名类 object1 = new Type(parameterList) { // 匿名类代码 }; }

以上的代码创建了一个匿名类对象 object1，匿名类是表达式形式定义的，所以末尾以分号 ; 来结束。 匿名类通常继承一个父类或实现一个接口。

01、匿名类继承一个父类

以下实例中，创建了 Polygon 类，该类只有一个方法 display()，AnonymousDemo 类继承了 Polygon 类并重写了 Polygon 类的 display() 方法<:/p>

class Polygon { public void display() { System.out.println("在 Polygon 类内部"); } } class AnonymousDemo { public void createClass() { // 创建的匿名类继承了 Polygon 类 Polygon p1 = new Polygon() { public void display() { System.out.println("在匿名类内部。"); } }; p1.display(); } } class Main { public static void main(String[] args) { AnonymousDemo an = new AnonymousDemo(); an.createClass(); } }

执行以上代码，匿名类的对象 p1 会被创建，该对象会调用匿名类的 display() 方法，输出结果为：在匿名类内部。

02、匿名类实现一个接口

interface Polygon { public void display(); } class AnonymousDemo { public void createClass() { // 匿名类实现一个接口 Polygon p1 = new Polygon() { public void display() { System.out.println("在匿名类内部。"); } }; p1.display(); } } class Main { public static void main(String[] args) { AnonymousDemo an = new AnonymousDemo(); an.createClass(); } }

输出结果为：在匿名类内部。

六、Java 包

包主要用来对类和接口进行分类。当开发 Java 程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类

import 语句

在 Java 中，如果给出一个完整的限定名，包括包名、类名，那么 Java 编译器就可以很容易地定位到源代码或者类。import 语句就是用来提供一个合理的路径，使得编译器可以找到某个类。