Java基础-面向对象

Java面向对象

对象

面向对象的思想,体现的是人所关注对象的信息聚集在了一个具体的物体上。人们就是通过对象的属性和行为来了解对象。

对于一个具体的对象而言,比如一部 iPhone 16,世上还有许多跟这部手机有着同样属性或行为的对象,我们为了方便将它们归类起来,提取出他们相同的属性和行为,而我们把归类起来的这个抽象的概念 ,称之为

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

类的定义:

  • 类是相同或相似对象的一种抽象,是对象的一个模板,它描述一类对象的行为和状态。

  • 类是具有相同属性和方法(行为)的对象的集合

属性是对象具有的特征。每个对象的每个属性都拥有特定值。我们上面讲过对象是一个具体并且确定的事物,正是对象属性的值来区分不同的对象,比如我们可以通过一个人的外貌特征区分他。

行为,在计算机中我们通过方法去实现对象的行为,而对象的方法便是对象所具有的操作,比如人会走路、会哭泣、会学习等等都是人的行为,也就是人的方法。

定义类

  1. 定义类名,用于区分不同的类。如下代码中 public class 后面跟的就是类名。class是声明类的关键字,类名后面跟上大括号,大括号里面就是类的一些信息。public 为权限修饰符。
public class 类名 {
    //定义属性部分(成员变量)
    属性1的类型 属性1;
    属性2的类型 属性2;
    ...
    //定义方法部分
    方法1
    方法2
    ...
}

  1. 编写类的属性。对象有什么,需要通过属性来表示。属性的定义是写在类名后面的大括号里,在定义属性时,要明确属性的类型。在一个类当中可以写一个或多个属性。当然也可以不定义属性。

  2. 编写类的方法。方法也是写在大括号里面。可以定义一个方法或多个方法,当然也可以不定义方法。

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

  • 局部变量:在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。
  • 成员变量:成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
  • 类变量:也叫静态变量,类变量也声明在类中,方法体之外,但必须声明为 static 类型。

局部变量的作用域仅限于定义它的方法内。而成员变量的作用域在整个类内部都是可见的。
同时在相同的方法中,不能有同名的局部变量;在不同的方法中,可以有同名的局部变量。
成员变量和局部变量同名时,局部变量具有更高的优先级。 大家可以编写代码验证一下。

构造方法

每个类都有构造方法,在创建该类的对象的时候他们将被调用,如果没有定义构造方法,Java 编译器会提供一个默认构造方法。 创建一个对象的时候,至少调用一个构造方法

构造方法的名称必须与类名相同,一个类可以定义多个构造方法。

//与类同名,可以指定参数,没有返回值
public 构造方法名(){
//初始化代码
}

public class People{
    //无参构造方法
    public People(){

    }
    //有一个参数的构造方法
    public People(int age){

    }

    //构造函数,初始化了所有属性
    public People(double h, int a, int s){
        height = h;
        age = a;
        sex = s;
    }


}

People XiaoMing = new People(168, 21, 1);

  • 如果在定义类的时候没有写构造方法,系统会默认生成一个无参构造方法,这个构造方法什么也不会做。

  • 当有指定的构造方法时,系统都不会再添加无参构造方法了。

  • 构造方法的重载:方法名相同,但参数不同的多个方法 ,调用时会自动根据不同的参数选择相应的方法。

引用与对象实例

Object object=new Object();

那么变量 object 就真的是 Object 对象么,这里其实只是创建了一个 object 对象的引用。如果同学们学过 C 语言,这里就和指针一样,变量object保存的其实 Object 对象的引用,指向了 Object 对象。

引用与对象实例
在新建对象实例时,需要为对象实例设置一个对象名,就像这样

Object object=new Object();
copy
那么变量 object 就真的是 Object 对象么,这里其实只是创建了一个 object 对象的引用。如果同学们学过 C 语言,这里就和指针一样,变量 object 保存的其实 Object 对象的引用,指向了 Object 对象。



 ----------           ----------
 | object |---------> | Object |
 ----------           ----------
 |        |           |        |
 ----------           ----------
 |        |           |        |
 ----------           ----------
 |        |           |        |
 ----------           ----------
 |        |           |        |
 ----------           ----------

Object object1 = new Object();
Object object2 = object1;
System.out.println(object1 == object2);


true

运行得到的结果为 true,说明 object1 和 object2 的内存地址相同 (== 会比较两个对象的内存地址是否相同),它们实际上是 引用同一对象 ,如果改变 object1 对象内部的属性,那么 object2 的属性同样会改变,同学们可以下来验证这一点。

static

  • 静态成员

Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问。

public class StaticTest{
    public static String string="shiyanlou";
    public static void main(String[] args){
        //静态成员不需要实例化 直接就可以访问
        System.out.println(StaticTest.string);
        //如果不加static关键字 需要这样访问
        StaticTest staticTest=new StaticTest();
        System.out.println(staticTest.string);
        //如果加上static关键字,上面的两种方法都可以使用
    }
}

  • 静态方法
    被 static 修饰的方法是静态方法,静态方法不依赖于对象,不需要将类实例化便可以调用,由于不实例化也可以调用,所以不能有 this,也不能访问非静态成员变量和非静态方法。但是非静态成员变量和非静态方法可以访问静态方法。

final

final 关键字可以修饰类、方法、属性和变量

  • final 修饰类,则该类不允许被继承,为最终类
  • final 修饰方法,则该方法不允许被覆盖(重写)
  • final 修饰属性:则该类的属性不会进行隐式的初始化(类的初始化属性必须有值)或在构造方法中赋值(但只能选其一)
  • final 修饰变量,则该变量的值只能赋一次值,即常量public final static String SHI_YAN_LOU="shiyanlou";

权限修饰符

封装

  • 只能通过规定的方法访问数据。
  • 隐藏类的实例细节,方便修改和实现。
  1. 修改属性的可见性,在属性的前面添加修饰符 (private)
  2. 对每个值属性提供对外的公共方法访问如public,如创建 getter/setter(取值和赋值)方法,用于对私有属性的访问
  3. getter/setter 方法里加入属性的控制语句,例如我们可以加一个判断语句,对于非法输入给予否定。

public class People {
    //属性(成员变量)有什么,前面添加了访问修饰符private
    //变成了私有属性,必须通过方法调用
    private double height;     //身高

    //属性已经封装好了,如果用户需要调用属性
    //必须用getter和setter方法进行调用
    //getter和setter方法需要程序员自己定义
    public double getHeight(){
    //getter 方法命名是get关键字加属性名(属性名首字母大写)
    //getter 方法一般是为了得到属性值
      return height;
    }

    //同理设置我们的setter方法
    //setter 方法命名是set关键字加属性名(首字母大写)
    //setter 方法一般是给属性值赋值,所以有一个参数
    public void setHeight(double newHeight){
      height = newHeight;
    }
}


public class NewObject {

    public static void main(String[] args) {
        People LiLei = new People();    //创建了一个People对象LiLei

        //利用setter方法为属性赋值
        LiLei.setHeight(170.0);

        //利用getter方法取属性值
        System.out.println("LiLei的身高是"+LiLei.getHeight());
    }
}


this

this 关键字代表当前对象。使用 this.属性 操作当前对象的属性,this.方法 调用当前对象的方法。

用 private 修饰的属性,必须定义 getter 和 setter 方法才可以访问到 (Eclipse 和 IDEA 等 IDE 都有自动生成 getter 和 setter 方法的功能)。

public void setAge(int age) {
  this.age = age;
}
public int getAge() {
  return age;
}

继承

为了代码复用

class 子类 extends 父类
class Dog extends Animal {
    ...
}
  • 子类拥有父类除 private 以外的所有属性和方法。
  • 子类可以拥有自己的属性和方法。
  • 子类可以重写实现父类的方法。
  • Java 中的继承是单继承,一个类只有一个父类。

注:Java 实现多继承的一个办法是 implements(实现)接口,但接口不能有非静态的属性,这一点请注意。

super

super 关键字在子类内部使用,代表父类对象。

  • 访问父类的属性 super.属性名。
  • 访问父类的方法 super.bark()。
  • 子类构造方法需要调用父类的构造方法时,在子类的构造方法体里最前面的位置 :super()。

重载与重写

方法重载是指在一个类中定义多个同名的方法,但要求每个方法具有不同的参数的类型或参数的个数。方法重载一般用于创建一组任务相似但是参数不同的方法。

  • 方法中的 参数列表必须不同 。比如:参数个数不同或者参数类型不同。
  • 重载的方法中允许抛出不同的异常
  • 可以有不同的返回值类型 ,但是参数列表必须不同。
  • 可以有不同的访问修饰符。

public class Test {
    void f(int i) {
        System.out.println("i=" + i);
    }

    void f(float f) {
        System.out.println("f=" + f);
    }

    void f(String s) {
        System.out.println("s=" + s);
    }

    void f(String s1, String s2){
        System.out.println("s1+s2="+(s1+s2));
    }

    void f(String s, int i){
        System.out.println("s="+s+",i="+i);
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.f(3456);
        test.f(34.56f);
        test.f("abc");
        test.f("abc","def");
        test.f("abc",3456);
    }
}

方法重写 ,子类可以继承父类的方法,但如果子类对父类的方法不满意,想在里面加入适合自己的一些操作时,就需要将方法进行重写。并且子类在调用方法中,优先调用子类的方法。

当然在方法重写时要注意,重写的方法一定要与原父类的方法语法保持一致,比如 返回值类型,参数类型及个数,和方法名都必须一致



public class Animal {
    //类方法
    public void bark() {
        System.out.println("动物叫!");
    }
}




public class Dog extends Animal {
       //重写父类的bark方法
        public void bark() {
        System.out.println("汪!汪!汪!");
    }
}




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

          Animal b = new Dog(); // Dog 对象,向上转型为Animal类型,具体会在后面的内容进行详解

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


多态

多态是指 允许不同类的对象对同一消息做出响应 。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。多态也称作动态绑定(dynamic binding),是指在执行期间判断所引用对象的实际类型,根据其实际的类型调用其相应的方法。

  • 多态的实现条件
    Java 实现多态有三个必要条件:
  1. 继承、
  2. 重写
  3. 向上转型(即父类引用指向子类对象)。
Animal a = new Animal();  //a是父类的引用指向的是本类的对象

Animal b = new Dog(); //b是父类的引用指向的是子类的对象



  • 多态的实现方式
    Java 中多态的实现方式:继承父类进行方法重写,抽象类和抽象方法,接口实现。

向上转型

class Animal {
    //父类方法
    public void bark() {
        System.out.println("动物叫!");
    }
}

class Dog extends Animal {

    //子类重写父类的bark方法
    public void bark() {
        System.out.println("汪、汪、汪!");
    }
    //子类自己的方法
    public void dogType() {
        System.out.println("这是什么品种的狗?");
    }
}


public class Test {

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

        a.bark();
        b.bark();
        //b.dogType();
        //b.dogType()编译不通过
        d.bark();
        d.dogType();
    }

}
$ javac Test.java
$ java Test
动物叫!
汪、汪、汪!
汪、汪、汪!
这是什么品种的狗?

在这里,由于 b 是父类的引用,指向子类的对象,因此不能获取子类的方法(dogType() 方法), 同时当调用 bark() 方法时,由于子类重写了父类的 bark() 方法,所以调用子类中的 bark() 方法。

因此,向上转型,在运行时,会遗忘子类对象中与父类对象中不同的方法,也会覆盖与父类中相同的方法——重写(方法名,参数都相同)。

抽象类

抽象类中有抽象方法,这种方法是不完整的,仅有声明而没有方法体 。抽象方法声明语法如下:
abstract void f(); //f()方法是抽象方法

在某些情况下,某个父类只是知道其子类应该包含怎样的方法 ,但无法准确知道这些子类如何实现这些方法。也就是说抽象类是约束子类必须要实现哪些方法,而并不关注方法如何去实现。
从多个具有相同特征的类中抽象出一个抽象类,以这个抽象类作为子类的模板,从而避免了子类设计的随意性。

那抽象类如何用代码实现呢,它的规则如下:

  • 用 abstract 修饰符定义抽象类。
  • 用 abstract 修饰符定义抽象方法,只用声明,不需要实现。
  • 包含抽象方法的类就是抽象类。
  • 抽象类中可以包含普通的方法,也可以没有抽象方法。
  • 抽象类的对象不能直接创建,通常是定义引用变量指向子类对象。
//抽象方法
public abstract class TelePhone {
    public abstract void call();  //抽象方法,打电话
    public abstract void message(); //抽象方法,发短信
}

public class CellPhone extends TelePhone {

    @Override
    public void call() {
        System.out.println("我可以打电话!");
    }

    @Override
    public void message() {
        System.out.println("我可以发短信!");
    }

    public static void main(String[] args) {
        CellPhone cp = new CellPhone();
        cp.call();
        cp.message();
    }

}


接口

修饰符 interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法
}


// Animal.java
interface Animal {
        //int x;
        //编译错误,x需要初始化,因为是 static final 类型
        int y = 5;
        public void eat();
        public void travel();
}

// Cat.java
public class Cat implements Animal{

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

     public void travel(){
         System.out.println("Cat travels");
     }
     public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
        cat.travel();
    }
}

在 Java8 中:

  • 接口不能用于实例化对象。
  • 接口中方法只能是抽象方法、default 方法、静态方法。
  • 接口成员是 static final 类型。
  • 接口支持多继承。

内部类

将一个类的定义放在另一个类的定义内部,这就是内部类。

内部类的主要作用如下:

  • 内部类提供了更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类
  • 内部类的方法可以直接访问外部类的所有数据,包括私有的数据
  • 内部类所实现的功能使用外部类同样可以实现,只是有时使用内部类更方便
  • 内部类允许继承多个非接口类型(具体将在以后的内容进行讲解)

注:内部类是一个编译时的概念,一旦编译成功,就会成为完全不同的两类。对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类。编译完成后出现 outer.class 和 outer$inner.class 两类。所以内部类的成员变量 / 方法名可以和外部类的相同。

// People.java
//外部类People
public class People {
    private String name = "LiLei";         //外部类的私有属性
    //内部类Student
    public class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name:" + name);
            System.out.println("访问内部类中的ID:" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        People a = new People();     //创建外部类对象,对象名为a
        Student b = a.new Student(); //使用外部类对象创建内部类对象,对象名为b
        // 或者为 People.Student b = a.new Student();
        b.stuInfo();   //调用内部对象的suInfo方法
    }
}

  • Student 类相当于 People 类的一个成员变量,所以 Student 类可以使用任意访问修饰符。
  • Student 类在 People 类里,所以访问范围在类里的所有方法均可以访问 People 的属性(即内部类里可以直接访问外部类的方法和属性,反之不行)。
  • 定义成员内部类后,必须使用外部类对象来创建内部类对象,即 内部类 对象名 = 外部类对象.new 内部类();。
  • 如果外部类和内部类具有相同的成员变量或方法,内部类默认访问自己的成员变量或方法,如果要访问外部类的成员变量,可以使用 this 关键字。如上述代码中:a.this。
// People.java
//外部类People
public class People {
    private String name = "LiLei";         //外部类的私有属性

/*外部类的静态变量。
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问。
*/
    static String ID = "510xxx199X0724XXXX";

    //静态内部类Student
    public static class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name:" + (new People().name));
            System.out.println("访问外部类中的ID:" + People.ID);
            System.out.println("访问内部类中的ID:" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        Student b = new Student();   //直接创建内部类对象,对象名为b
        b.stuInfo();                 //调用内部对象的suInfo方法
    }
}

静态内部类不能直接访问外部类的非静态成员,但可以通过 new 外部类().成员 的方式访问。
如果外部类的静态成员与内部类的成员名称相同,可通过 类名.静态成员 访问外部类的静态成员;如果外部类的静态成员与内部类的成员名称不相同,则可通过 成员名 直接调用外部类的静态成员。
创建静态内部类的对象时,不需要外部类的对象,可以直接创建 内部类 对象名 = new 内部类();。

局部内部类

// People.java
//外部类People
public class People {
    //定义在外部类中的方法内:
    public void peopleInfo() {
        final String sex = "man";  //外部类方法中的常量
        class Student {
            String ID = "20151234"; //内部类中的常量
            public void print() {
                System.out.println("访问外部类的方法中的常量sex:" + sex);
                System.out.println("访问内部类中的变量ID:" + ID);
            }
        }
        Student a = new Student();  //创建方法内部类的对象
        a.print();//调用内部类的方法
    }
    //定义在外部类中的作用域内
    public void peopleInfo2(boolean b) {
        if(b){
            final String sex = "man";  //外部类方法中的常量
            class Student {
                String ID = "20151234"; //内部类中的常量
                public void print() {
                    System.out.println("访问外部类的方法中的常量sex:" + sex);
                    System.out.println("访问内部类中的变量ID:" + ID);
                }
            }
            Student a = new Student();  //创建方法内部类的对象
            a.print();//调用内部类的方法
        }
    }
    //测试方法内部类
    public static void main(String[] args) {
        People b = new People(); //创建外部类的对象
        System.out.println("定义在方法内:===========");
        b.peopleInfo();  //调用外部类的方法
        System.out.println("定义在作用域内:===========");
        b.peopleInfo2(true);
    }
}

匿名内部类

匿名内部类,顾名思义,就是没有名字的内部类。正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编写。但使用匿名内部类还有个前提条件: 必须继承一个父类或实现一个接口。

// Outer.java
public class Outer {

    public Inner getInner(final String name, String city) {
        return new Inner() {
            private String nameStr = name;
            public String getName() {
                return nameStr;
            }
        };
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Inner inner = outer.getInner("Inner", "NewYork");
        System.out.println(inner.getName());
    }
}
interface Inner {
    String getName();
}

Inner

package

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

包的命名规范是全小写字母拼写。

posted @ 2020-10-07 10:44  不洗澡的鲸鱼  阅读(19)  评论(0编辑  收藏