Java类、封装、继承的方法

这篇文章主要讲解了“Java类、封装、继承的方法”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Java类、封装、继承的方法”吧！

什么是类成员

使用static修饰的成员方法和成员变量称为类成员

使用static修饰的成员变量叫做类变量

使用static修饰的成员方法叫做类方法

什么是实例变量

未使用static修饰的成员方法和成员变量称为实例成员

未使用static修饰的成员变量叫做实例变量

未使用static修饰的成员方法叫做实例方法

例如：

public String name;  //这个就是实例成员（属性） public static int age;//这个就是类成员（属性） public void a(){System.out.println("我叫："+this.name)}                                    //这个没有加static的方法就是实例方法public static void a(){           //这个加了static的方法就是类方法System.out.println("我叫："+this.name)}

那么实例变量和类变量的区别呢？

• 所有该类的对象共享同一个类变量，但是每个对象都会有自己独特的实例变量

• 所有该类的对象都能改变类变量的值，但是每个对象只能改变自己的实例变量值

• 实例变量在使用前必须创建一个对象，根据对象名.变量名使用，但是类变量不需要创建对象

//定义一个类public class stu {    public String name;  //这个类有一个名字这个属性，属于实例成员，也就是需要实例化对象了才可以使用    //定义构造方法    public stu(){}    //不管怎么样，都定义一个无参构造    public stu(String name){    //定义有参构造，需要传入一个字符串名字       this.name = name;         //这里若不使用this 关键字，那么是不会与上面的实例属性匹配    }    //定义方法    public void a(){        System.out.println(this.name);    }}

使用该类：

public class stu_Test {    public static void main(String[] args) {        //实例化两个对象，基于stu类        stu s1 = new stu("小红");           stu s2 = new stu("小王");        //使用stu类里面的方法        s1.a();        s2.a();    }        //stu s1 = new stu("小红");  将会输出小红    //stu s2 = new stu("小王");  将会输出小王}//通过这个就可以明白每个对象都有属于自己的实例变量（属性）

那么类方法和实例方法的区别？

• 所有该类对象共享类方法和实例方法

• 类方法使用类名.方法名([参数])调用即可，不需要实例化对象后使用

• 实例方法使用对象名.方法名([参数])调用

static关键字

Java类提供了两种类型的变量：用static关键字修饰的静态变量和不用static关键字修饰的实例变量。 静态变量属于类，在内存中只有一个复制，只要静态变量所在的类被加载，这个静态变量就会被分配空间，因此就可以被使用了。对静态变量的引用有两种方式，分别是“类.静态变量"和”对象.静态变量"

static成员方法：

• static方法是类的方法，不需要创建对象就可以被调用，而非static方法是对象的方法，只有对象被创建出来后才可以被使用

• static方法中不能使用this和super关键字，不能调用非static方法，只能访问所属类的静态成员变量和成员方法，因为当static方法被调用时，这个类的对象可能还没被创建，即使已经被创建了，也无法确定调用哪个对象的方法。

static用处：

• 修饰成员变量

• 修饰成员方法

• 静态代码块

• 修饰类【只能修饰内部类也就是静态内部类】

• 静态导包

static注意事项： 静态只能访问静态，非静态既可以访问非静态的，也可以访问静态的。

封装：

封装的概念

把客观事物封装成抽象的类，并且类可以把自己的属性和方法只让可信的类或者对象进行操作，对不可信的类或者对象隐藏，这样的过程叫做封装。 简而言之：把自己的信息封闭起来，只给自己信任的人看和使用

封装的分类

• 对属性的封装：将属性设置为private(私有)，限制其只能在类的内部使用

• 对方法的封装：对于方法的封装，将外部可以访问方法设置为public,将外部不能访问的方法设置为private

封装的使用

在将封装之前，我们先学习一下一个新的修饰符：private private：限制其只能在类的内部使用（也就是说被private修饰的方法和属性，只能在这个类内被发现和使用，在这个类外，是找不到这个属性的存在，这也达到了封装的效果）

//给name这个属性进行封装private Strint name; //即可，这也我们在类外是找不到这个属性的存在的

既然封装了，肯定也有对这个封装进行修改和使用的方法，是的，这就是get/set方法

get/set方法

public class stu {    private String name;     public void setName(String name){    //set方法：对象调用这个方法，即可对私有属性进行修改        this.name = name;       }    public String getName(){         //get方法：对象调用这个方法，就可以使用该方法        return name;    }}

使用：

public class stu_Test {    public static void main(String[] args) {    stu s =new stu();    s.setName("小红");  //给name 这个私有属性修改值为小红        System.out.println(s.getName());   }

//程序运行后，输出值就是小红

继承：

什么是继承

一个新类可以从现有的类派生，这样的过程叫做继承

在继承的过程中，新类被称为子类，现有的类被称为父类，子类将会继承父类的属性和行为。

继承语法：

public class stu extends Student{   //在类名后加上extends，在写上继承的父类即可//这里可以写父类没有发属性及方法public String ID;  //等等等等}

注意： 继承不能继承父类的私有属性和方法！！！只要被private修饰的，都不被继承！！！

关于子类： 子类除了可以拥有父类非私有的属性和方法外，也可以扩展自己的属性和方法

继承的使用：

• 继承是单继承，也就是一个类只能有一个父类。

• 如果一个类没有显式的继承某一个类，那么它有一个默认的父类是java.lang.Object类

• 继承了父类非私有的成员变量和成员方法，但是请注意：子类是无法继承父类的构造方法的

简而言之：一个子类只能继承一个父类，如果这个类没有继承别的类，默认继承Object类（Java自带）

无法继承父类的构造方法。

方法的重写：

@overriding

什么是方法重写？：

• 子类根据需求从父类继承的方法进行重新编写（方法名一样）

• 重写是可以使用super方法的方式来保留父亲的方法（super在后面讲到）

注意：构造方法不能被重写

方法重写的规则：

• 方法名相同，参数列表相同（数量，顺序，数据类型）

• 如果有返回值，返回值相同或者是其子类，访问权限不能严于父类

• 父类的静态方法不能被重写为非静态方法，反之父类的非静态方法不能被重写为静态方法

• 子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法**（静态方法中无法使用super、this）**

• 父类的私有方法不能被子类重写（private修饰的）

上代码：

定义一个类，有名字和年龄的属性，分别有get/set方法，成员方法是输出名字和年龄:

public class Person {    private String name;    private int age;    //get/ste方法    public void setName(String name){        this.name = name;    }    public String getName(){        return name;    }    public void setAge(int age){        this.age = age;    }    public int getAge(){        return age;    }    //成员方法：    public void print(){        System.out.println("我叫："+this.name+","+"我今年："+this.age+"岁");    }}

写一个类，继承Person类，并且这个类拥有自己的一个sex属性，提供get/set方法 并且重写父类的print方法，输出名字+年龄+性别

public class child extends Person{    private String sex;      //这个child类继承了Person类，但也拥有自己的属性 sex性别    public void setSex(String sex){        this.sex = sex;    }    public String getSex(){        return sex;    }    @Override    //重写父类方法： 因为父类是输出名字和年龄，这里要输出名字，年龄和性别    public void print(){        System.out.println("我叫："+getName()+","+"我今年："+getAge()+"岁"+","+"我是"+sex+"孩子");    }}

新建测试类，测试两个类的继承、重写

//测试类，public class Test {    public static void main(String[] args) {        child c = new child();        c.setName("小红");        c.setAge(20);        c.setSex("男");        c.print();    }}//分别执行child继承person的set方法，使用重写后的方法，

//输出结果为： 我叫：小红,我今年：20岁我是男孩子

super关键字：

super代表的是父类对象

super的使用方式：

super.属性名 用于在子类中调用父类被隐藏的同名实例变量

super([参数列表]) 用于在子类的构造方法中调用父类的构造方法

注意事项：

• 每一个子类的构造方法在没有显示调用super()，系统都会提供一个默认的super()

• super() 书写在第一行

• 可以在子类构造方法中显示调用super(),完成对特定父类构造方法的调用

简而言之：super就是调用父亲的属性和方法来使用

上代码：

新建一个类：定义age为20

public class super_test {    public int age=20;    public void print(){        System.out.println(this.age);    }}

建第二个类，继承第一个类；

public class su2 extends super_test{    public int age = 10;    @Override    public void print(){        System.out.println(super.age);  //这里使用super，意思是使用父类的age    }}

建立测试类：

public class test {    public static void main(String[] args) {    su2 s = new su2();    s.print();}}

这样输出的就是20，是父类的age

this与super的区别:

• super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函 数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）

• this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的 形参与类中的成员数据同名，这时需用this来指明成员变量名

• super()和this()类似,区别是，super()在子类中调用父类的构造方法，this()在本类内调用本类的其 它构造方法。

• super()和this()均需放在构造方法内第一行,尽管可以用this调用一个构造器，但却不能调用两个

• this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造 函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意 义，编译器也不会通过。

• this()和super()都指的是对象，所以，均不可以在static环境中使用。包括： static变量,static方法，static语句块。

• 从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

感谢各位的阅读，以上就是“Java类、封装、继承的方法”的内容了，经过本文的学习后，相信大家对Java类、封装、继承的方法这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是编程网，小编将为大家推送更多相关知识点的文章，欢迎关注！