大数据学习——《java的类、对象、方法》

最新推荐文章于 2023-05-17 21:39:54 发布

hongjunGu

最新推荐文章于 2023-05-17 21:39:54 发布

阅读量918

点赞数 15

分类专栏：大数据

本文链接：https://blog.csdn.net/qq_38331988/article/details/97623414

版权

大数据专栏收录该内容

2 篇文章 0 订阅

订阅专栏

java类、对象、方法

资料来源于视频课程和其他收集，个人整理，如有侵权请联系。

1.类

类是对象的抽象表示，比如中华田园犬是属于犬类。
属性是对象的特征，比如狗的毛色就是狗的属性。
方法是对象的功能，比如狗会叫，叫就是方法。

下面的程序定义一个人类：

public class People {
//属性（成员变量） 有什么
    double height;  //身高
    int age;     //年龄
    int sex;    //性别，0为男性，非0为女性

//方法 干什么
    void cry(){
        System.out.println("我在哭！");
    }
    void laugh(){
        System.out.println("我在笑！");
    }
    void printBaseMes(){
        System.out.println("我的身高是"+height+"cm");
        System.out.println("我的年龄是"+age+"岁");
        if(this.sex==0)
            System.out.println("我是男性！");
        else 
            System.out.println("我是女性！");
    }
}

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

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

2.对象

创建对象的语法如下：

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

实例化xiaoming这个人：


People xiaoming = new People();

定义类的时候不会为类开辟内存空间，但是一旦创建了对象，系统就会在内存中为对象开辟一块空间，用来存放对象的属性值和方法。

下面调用people类创建并使用对象：

public class NewObject {
    public static void main(String[] args) {
        People xaioming = new People(); //创建一个People对象xiaoming
        xiaoming.height =170;	//给成员变量赋值。
        xiaoming.age = 20;
        xiaoming.sex = 1;
        xiaoming.printBaseMes();
    }
}

注意：成员变量和局部变量同名时，局部变量具有更高的优先级。

3.构造方法

每个类都有构造方法，在创建该类的对象的时候他们将被调用，如果没有定义构造方法，Java 编译器会提供一个默认构造方法。创建一个对象的时候，至少调用一个构造方法。比如在新建一个对象new Object()，括号中没有任何参数，代表调用一个无参构造方法（默认构造方法就是一个无参构造方法）。构造方法的名称必须与类名相同，一个类可以定义多个构造方法。

构造方法的具体内容：

1、构造方法的名称与类名相同，且没有返回值。它的语法格式如下：

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

下面是一个构造方法的例子：

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

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

    }
}

又例如具体的构造方法：

public class People {
//属性（成员变量）有什么
    double height;     //身高
    int age;           //年龄
    int sex;       //性别，0为男性，非0为女性

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

//创建对象，调用我们自己定义的有参构造方法
People XiaoMing = new People(168, 21, 1);

上面的例子中通过new关键字将类实例化成对象，而new后面跟的就是构造方法。于是可以知道new + 构造方法可以创建一个新的对象。
2、如果在定义类的时候没有写构造方法，系统会默认生成一个无参构造方法，这个构造方法什么也不会做。
3、当有指定的构造方法时，系统都不会再添加无参构造方法了。
4、构造方法的重载：方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法。

4、对象实例其实是一个类的引用

在新建对象实例时，需要为对象实例设置一个对象名，如下

Object object=new Object();

这里其实只是创建了一个 object 对象的引用，就像c语言的指针，变量 object 保存的其实 Object 对象的引用，指向了 Object 对象。
例：

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

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

5、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，也不能访问非静态成员变量和非静态方法。但是非静态成员变量和非静态方法可以访问静态方法。

6.final

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

final 修饰类，则该类不允许被继承，为最终类
final 修饰方法，则该方法不允许被覆盖（重写）
final 修饰属性：则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值（但只能选其一）
final 修饰变量，则该变量的值只能赋一次值，即常量
如：
//静态常量
public final static String SHI_YAN_LOU=“shiyanlou”;

7、权限修饰符

代码中经常用到private和public修饰符，权限修饰符可以用来修饰属性和方法的访问范围。
在这里插入图片描述
如图所示，代表了不同的访问修饰符的访问范围，比如private修饰的属性或者方法，只能在当前类中访问或者使用。默认是什么修饰符都不加，默认在当前类中和同一包下都可以访问和使用。protected修饰的属性或者方法，对同一包内的类和所有子类可见。public修饰的属性或者方法，对所有类可见。

8、封装

即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别

如何实现封装：

修改属性的可见性，在属性的前面添加修饰符(private)
对每个值属性提供对外的公共方法访问，如创建 getter/setter（取值和赋值）方法，用于对私有属性的访问
在 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 XiaoMing
{
	public static void main(String[] args)
	{
		People xiaoming = new People();
		xiaoming.setHeight(170.0);
		System.out.println(xiaoming.getHeight());
	}
}

9.this的使用

this关键字代表当前对象。使用this.属性操作当前对象的属性，this.方法调用当前对象的方法。
用private修饰的属性，必须定义 getter 和 setter 方法才可以访问到
如下：

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

创建好了 getter 和 setter 方法后，我们发现方法中参数名和属性名一样。
当成员变量和局部变量之间发生冲突时，在属性名前面添加了this关键字。此时就代表将一个参数的值赋给当前对象的属性，同理this关键字可以调用当前对象的方法。

10.继承

(1)父类

public class Father {
	private int money = 100;  //私有
	long mobile = 13999999999L;
	
	public void hello()	{
		System.out.println("hello");
	}
}

(2)子类

public class Son extends Father {
	public void hi() {
		//子类可以扩展自己的成员方法
		System.out.println("hi~~~~~");
	}
	
	public static void main(String[] a)	{
	    Son s = new Son();
	    System.out.println(s.mobile); //Son没有定义mobile, 而是通过父类继承的
	    //System.out.println(s.money); //error 父类的money是私有的，子类无法直接访问
	    s.hello();  //Son没有定义hellow方法, 而是通过父类继承的
	    s.hi();     //Son可以自定义自己的成员方法
	}
}

如上程序，Son类是继承于Father类的，除了Father类的私有变量，Son类都可以使用，同时可以拓展自己的方法和属性。执行时两个类文件分开写，先运行父类再运行子类即可。
继承的特点：
• 子类拥有父类除 private 以外的所有属性和方法（可以通过
• 子类可以拥有自己的属性和方法
• 子类可以重写实现父类的方法
• Java 中的继承是单继承，一个类只有一个父类
注： Java 实现多继承的一个办法是 implements（实现）接口

11.方法的重载和重写

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

public class OverloadeTest 
{
	public static int add (int a, int b) {
		return a + b;
	}
	public static double add (double a, double b) {
		return a + b;
	}
	//方法名一样，参数不一样，也可以执行通过，叫做方法的重载。
	public static void main (String [] args)
	{
		System.out.println(add (2,3));
		System.out.println(add (1.5,2.5));
	}
}

上面的程序首先定义了一个类OverloadeTest，再定义了两个方法名字都是add，这种情况叫方法的重载，还有一个main函数用来调用其他方法,方法可以互相调用，执行程序内容。
（2）重写
重写是指子类继承父类时可以对父类的方法进行修改，重写的方法一定要与原父类的方法语法保持一致，比如返回值类型，参数类型及个数，和方法名都必须一致。
例如：

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 类的方法
       }
}

编译运行：
$ javac Test.java Dog.java Animal.java
$ java Test
动物叫！
汪！汪！汪！
汪！汪！汪！

12.对象直接定义在类内部

public class OOExample{
	private int a;		//本类的私有变量
	public void setA(int a)	//自定义方法
	{
		this.a = a;
	}
	public int add(int b)	//自定义方法
	{
		return this.a + b;
	}
	public static void main(String[] a)
	{
		int b = 5;
		OOExample obj = new OOExample();	//定义OOExample类的对象
		obj.setA(10);	//对象调用setA()方法
		System.out.println(obj.add(b));		//对象调用add()方法
	}
}

如上面的程序，obj就是对象，这个对象定义在类的内部可以调用类之中的所有方法。

13.super

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

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

14.向上转型

假设Animal类是父类，Dog类是子类。

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

由于 Dog 继承于 Animal，所以 Dog 可以自动向上转型为 Animal，所以 b 是可以指向 Dog 实例对象的。如果定义了一个指向子类对象的父类引用类型，那么它除了能够引用父类中定义的所有属性和方法外，还可以使用子类强大的功能（指的是子类重写的父类方法）。但是对于只存在于子类的方法和属性就不能获取。

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()方法。
因此，向上转型，在运行时，会遗忘子类对象中与父类对象中不同的方法，也会覆盖与父类中相同的方法——重写。（方法名，参数都相同）

15.抽象类

在定义类时，前面加上abstract关键字修饰的类叫抽象类。抽象类中至少要有一个抽象方法，这种方法是不完整的，仅有声明而没有方法体。抽象方法声明语法如下：

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) {
        TelePhone cp = new CellPhone();     //向上转型。
        cp.call();
        cp.message();
    }

}

抽象类也是类，如果一个子类继承了抽象类，它就不能再继承于其他类，而且要实现父类抽象类的所有抽象方法。

16.接口

如果一个程序所有的方法都未实现，那么我们就可以把它定义为接口。我们为什么需要接口呢，因为接口可以实现多继承，这弥补了普通类单继承的不足，接口可以继承于其他接口，这样未实现方法就会叠加，子类继承了接口就要实现接口的所有方法。

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

注意点：在Java8中
接口不能用于实例化对象
接口中方法只能是抽象方法、default 方法、静态方法
接口成员是 static final 类型
接口支持多继承
抽象类也可以实现接口，而且可以把接口的方法写成抽象方法而不实现它。
在Java9中，接口可以拥有私有方法和私有静态方法，但是只能被该接口中的 default 方法和静态方法使用。

多继承实现：
接口继承接口

修饰符 interface A extends 接口1，接口2{
}
类继承接口
修饰符 class A extends 类1 	implements 接口1，接口2{
}

实现接口Animal
// 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();
    }
}

17.内部类

内部类
将一个类的定义放在另一个类的定义内部，这就是内部类。而包含内部类的类被称为外部类。
内部类的主要作用如下：

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
内部类的方法可以直接访问外部类的所有数据，包括私有的数据
内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
内部类允许继承多个非接口类型（具体将在以后的内容进行讲解）
注：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为 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方法
    }
}

编译运行：

$ javac People.java                                 $ java People
访问外部类中的name：LiLei
访问内部类中的ID：20151234

成员内部类的使用方法：

Student 类相当于 People 类的一个成员变量，所以 Student 类可以使用任意访问修饰符
Student 类在 People 类里，所以访问范围在类里的所有方法均可以访问 People 的属性（即内部类里可以直接访问外部类的方法和属性，反之不行）
定义成员内部类后，必须使用外部类对象来创建内部类对象，即内部类对象名 = 外部类对象.new 内部类();
如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字如上述代码中：a.this
注：成员内部类不能含有 static 的变量和方法，因为成员内部类需要先创建了外部类，才能创建它自己的。

静态内部类:

静态内部类通常被称为嵌套类。
// 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方法
    }
}
编译运行：
$ javac People.java
$ java People
访问外部类中的name：LiLei
访问外部类中的ID：510xxx199X0724XXXX
访问内部类中的ID：20151234

静态内部类是 static 修饰的内部类，这种内部类的特点是：

静态内部类不能直接访问外部类的非静态成员，但可以通过 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);
    }
}
编译运行：
$ javac People.java
$ java People
定义在方法内：===========
访问外部类的方法中的常量sex：man
访问内部类中的变量ID:20151234
定义在作用域内：===========
访问外部类的方法中的常量sex：man
访问内部类中的变量ID:20151234

局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。

18.package

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
包的作用
• 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
• 包采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。
• 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
定义包语法：

package 包名
//注意：必须放在源程序的第一行，包名可用"."号隔开

例如：

//在定义文件夹的时候利用"/"来区分层次
//包中用"."来分层
package com.shiyanlou.java 
不仅是我们这样利用包名来区分类，系统也是这样做的。

如何在不同包中使用另一个包中的类？
使用import关键字。比如要导入包com.shiyanlou下People这个类，import com.shiyanlou.People。同时如果import com.shiyanlou.*这是将包下的所有文件都导入进来，*是通配符。
包的命名规范是全小写字母拼写。

hongjunGu

关注

15
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
大数据学习——《java的类、对象、方法》

java类、对象、方法1.类2.对象3.构造方法4、对象实例其实是一个类的引用5、static6.final7、权限修饰符8、封装9.this的使用10.继承11.方法的重载和重写12.对象直接定义在类内部13.super14.向上转型15.抽象类16.接口17.内部类18.package资料来源于视频课程和其他收集，个人整理，如有侵权请联系。1.类类是对象的抽象表示，比如中华田园犬是属于犬...
复制链接

扫一扫

专栏目录