Java面向对象与继承详解-优快云博客

本文链接：https://blog.youkuaiyun.com/wuzj1314/article/details/121151391

类中的方法和变量是怎么使用的呢？通过对象来调用类里面的变量和方法来使用

1.对象

1.1对象定义

（1）对象是由我们自己创建的类来实现的。

（2）对象就是类的具体实现，类的实例。【可以真正使用类的数据可以调用类中元素的数据】

例如：修建大楼时绘制的设计图纸就是类，根据设计图纸修建起来的真是的可以住人的大楼就是对象。

（3）没有类就没有对象

（4）一个类可以创建多个对象

（5）类是对象的模板，对象是类的真实表现

1.2对象作用

创建好的对象用来访问/调用类中的元素【变量/方法】，至于创建好的对象可以访问/调用类中的那些元素，那些元素不能访问/调用，就得看类中元素的访问限制修饰符。

1.3如何创建对象？【new】

格式：new 构造方法([参数值])

（1）当前类中---new+构造方法---this

（2）其他类中---new+构造方法

主方法中调用，创建类对象，new 构造方法( [参数值] )；往往我们创建出来的对象需要当前类的数据类型对应的变量来保存这个对象。

例：

public class Person {

      //无参数构造方法

      public Person(){

            System.out.println("无参数构造方法");

      }

      //有参数构造方法

      public Person(String name){

            System.out.println("有参数构造方法，参数是name=="+name);

      }

}

测试类：

public class TestMain1 {

      public static void main(String[] args) {

            //创建Person的对象

            //new Person();

            //但是创建好的对象已经是变量了

            //往往需要用当前类的数据类型对应的变量保存起来

            //所以以后可以一步到位

            Person per1=new Person();//数据类型   变量名称=new 数据类型();

            Person per2=new Person("zhangsan");

      }

}

输出:

无参数构造方法

有参数构造方法，参数是name==zhangsan

1.4对象访问变量

（1）局部变量在其他类中不能访问

（2）实例变量只能对象访问

（3）静态变量可以类名访问，也可以对象访问

（4）实例变量在同一个类的多个对象之间不能数据共享

静态变量在同一个类的多个对象之间可以数据共享

public class TestMain1 {

   public static void main(String[] args) {

            //创建Person的对象

            //new Person();

            //但是创建好的对象已经是变量了

            //往往需要用当前类的数据类型对应的变量保存起来

            //所以以后可以一步到位

            Person per1=new Person();//数据类型   变量名称=new 数据类型();

            Person per2=new Person("zhangsan");

            //对象访问变量

            //1.局部变量在其他类中不能访问

            //2.实例变量只能对象访问

            per1.test1="zhangsan";//per1  per2 都可以

            System.out.println("实例变量=="+per1.test1);

            String str1=per1.test1;

            System.out.println("实例变量==str1=="+str1);

           

            //3.静态变量类名访问，可以对象访问

            Person.dox1="lisi";//类名访问

            per1.dox1="wangwu";

            System.out.println("静态变量=="+Person.dox1);

            System.out.println("静态变量=="+per1.dox1);

            String name1=Person.dox1;

            String name2=per1.dox1;

            System.out.println("静态变量==name1=="+name1);

            System.out.println("静态变量==name2=="+name1);

           

            //4.实例变量在同一个类的多个对象之间不能数据共享

            per1.test1="zhangsan";

            per2.test1="lisi";

            System.out.println("per1.test1=="+per1.test1);//zhangsan

            System.out.println("per2.test1=="+per2.test1);//lisi

            per1.test1="zhangsansan";

            per2.test1="lisisi";

            System.out.println("per1.test1=="+per1.test1);//zhangsansan

            System.out.println("per2.test1=="+per2.test1);//lisisi

           

            // 静态变量在同一个类的多个对象之间可以数据共享

            per1.dox1="zhangsan";

            per2.dox1="lisi";

            System.out.println("per1.dox1=="+per1.dox1);//lisisi

            System.out.println("per2.dox1=="+per2.dox1);//lisi

            per1.dox1="zhangsansan";

            per2.dox1="lisisi";

            System.out.println("per1.dox1=="+per1.dox1);//lisisi

            System.out.println("per2.dox1=="+per2.dox1);//lisisi

      }

}

测试类：

public class TestMain1 {

      public static void main(String[] args) {

            //创建Person的对象

            //new Person();

            //但是创建好的对象已经是变量了

            //往往需要用当前类的数据类型对应的变量保存起来

            //所以以后可以一步到位

            Person per1=new Person();//数据类型   变量名称=new 数据类型();

            Person per2=new Person("zhangsan");

      }

}

1.5对象访问方法

（1）构造方法的访问------new

（2）实例方法只能对象访问

（3）静态方法类名访问，可以对象访问

（4）有参数的方法访问，需要注意参数的传递【要什么，给什么】

两种方式，①创建对象括号里直接给值，叫传值；②创建对象括号里是变量，所以要给变量赋值，前面要先定义变量给值，叫传变量。

（5）有返回值的方法访问，需要注意的是接收方法的返回值结果【类型匹配】，即调用有返回值的方法需要定义变量（返回值同类型）来接收方法的返回值【给什么，收什么】

方法代码：

public class TestClass {

      //无参数的构造方法

      public TestClass(){

            System.out.println("无参数的构造方法");

      }

      //有参数的构造方法

      public TestClass(String name){

            System.out.println("有参数的构造方法---参数name="+name);

      }

      //无参数实例方法

      public void shilimethod(){

            System.out.println("无参数实例方法");

      }

      //有参数的实例方法

      public void shilimethod1(int id,String name){

            System.out.println("有参数的实例方法---参数id="+id+";name="+name);

      }

      //有返回值的实例方法

      public String shilimethod2(){

            System.out.println("有返回值的实例方法");

            return "zhangsan";

      }

      //有参数，有返回值的实例方法

      public String shilimethod3(int id,String name){

            System.out.println("有参数,有返回值的实例方法");

            String info=id+name;

            return info;

      }

      //无参数静态方法

      public static void staticmethod(){

            System.out.println("无参数静态方法");

      }

      //有参数的静态方法

      public static void staticmethod1(int id,String name,int age){

            System.out.println("有参数的实例方法---参数id="+id+";name="+name+";age="+age);

      }

      //有返回值的静态方法

      public static int staticmethod2(){

            System.out.println("有返回值的静态方法");

            return 1000;

      }

      //有返回值有参数的静态方法

      public static int staticmethod3(int id,String name,int age){

            System.out.println("有参数,有返回值的静态方法");

            int num=id+age;

            return num;

      }

}

测试类：

public class TestMain2 {



      public static void main(String[] args) {

         //访问构造方法

            TestClass tc1=new TestClass();

            TestClass tc2=new TestClass("zhangsan");//传值

            //访问实例方法

            tc1.shilimethod();//访问无参数的实例方法

            tc2.shilimethod1(1000,"lisi");//有参数的，要传递参数，传值【要什么给什么】

           

            //访问静态方法

            TestClass.staticmethod();//访问无参数的静态方法，类名访问

            tc1.staticmethod();//访问无参数的静态方法，对象名访问

            TestClass.staticmethod1(1001, "wangwu", 18);//访问有参数的静态方法，传值 

           

            //或者传变量,创建对象里面有参数需要给值，可以先用变量给值再传变量

            String name1="zhangsan";

            TestClass tc3=new TestClass(name1);

            int id1=1000;

            String name2="lisi";

            tc3.shilimethod1(id1,name2);

            int id2=1001;

            String name3="wangwu";

            int age=18;

            TestClass.staticmethod1(1001, "wangwu", age);

     

            //有返回值的方法访问，需要注意的是接收方法的返回值结果【类型匹配】【给什么，收什么】

            TestClass tc4=new TestClass();

            //tc4.shilimethod2();

            String fhz= tc4.shilimethod2();//接收返回值

            System.out.println("有返回值的无参数实例方法返回值="+fhz);//测试有没有收到返回值

            tc2.shilimethod3(666,"hahaha");

            String fhz1=tc2.shilimethod3(666,"hahaha");//接收返回值

            System.out.println("有返回值的有参数实例方法返回值="+fhz1);//测试有没有收到返回值

           

            tc2.staticmethod3(55,"zhangjing",23);

            int fhz2=tc2.staticmethod3(55,"zhangjing",23);

            System.out.println("有返回值的有参数静态方法返回值="+fhz2);//测试有没有收到返回值

      }

}

1.6 对象的内存分配原理

2.继承

类与类之间有没有关系？如果有这种关系是什么？这种关系有什么特征？

2.1 继承定义

（1）类与类之间有关系，这种关系就是继承。

（2）继承就是通过现有的类构建出新类的机制。

（3）现有的类叫父类【超类】，构建出来的新类叫子类。

（4）类与类之间的继承关系是单继承，一个java类只能有一个父类。

2.2 如何完成一个继承关系

通过extends关键字实现继承。

格式：public class 子类名称 extends 父类名称{ }

前提是父类一定是存在的。

例如：

public class Person{ }

public class Student extends Person{ }

2.3 子类对象创建过程

子类对象创建--子类的构造方法中会默认调用父类的无参数构造方法【没有父就没有子】

如果一定要访问父类有参数的构造方法，就需要在子类的构造方法中的第一行通过“super(参数值)”，就可以指定调用父类的任意一个构造方法。

例：

public class Person {

      public Person(){

            System.out.println("无参数父类构造方法");

      }

   public Person(String name){

            System.out.println("有参数父类构造方法--参数name="+name);

      }

}

public class Student extends Person{

      public Student(){

            //super();//被隐藏

            super("zhangsan");//手动写出super(参数)，可以访问父类有参数构造方法

            System.out.println("子类无参数构造方法");

      }

}

测试类：

public class TestMain3 {

   public static void main(String[] args) {

            /*   输出发现不仅输出了子类无参数构造方法

            还输出了父类无参数构造方法

            原因是子类构造方法中默认存在一个super();无参数，只不过被隐藏了

            */

            new Student();

      }

}

总结:创建子类对象需要子类的构造方法，通过子类构造方法创建子类对象是默认会调用父类的无参数构造方法，当父类没有无参数构造方法时，我们应该在子类的构造方法中的第一行通过super(参数)，调用父类有参数得构造方法来完成子类对象的创建。

2.4 关于java包

（1）Java程序包，通过package关键字创建包

（2）格式：在类的最上面第一行

package 包名称;

（3）java包作用：区分名称相同的Java类

2.5 如何导包

通过import关键字导入需要使用的java包

例如:import 包名+类名; //只导入当前包中的当前类

例如:import 包名+*; //导入当前包中的所有类

包名可以是一个合法的标识符，也可以是多个合法标识符之间用"."分割

包名称规则：公司域名倒置.项目.功能

注意：java.lang包不需要导入。【java.lang包，包含的java的核心开发类，系统默认自动导入】

2.6 java中的访问限制修饰符的区别和用法

（1）java中有四种权限修饰符，分别是public【公共的】，protected【受保护的】，default【缺省的/友好的】，private【私有的】

（2）类上（创建类那一行）有：

public------任何地方都可以访问，不用担心跨包

default【缺省的/友好的】------跨包不能访问

（3）类中里面有：

java类中的变量------public，protected，default ，private

java类中的方法------public，protected，default，private

方法和变量结果一样，下面只测试变量

修饰符	同一个类中	同一个包中的非子类	同一个包中的子类	不同包子类	不同包非子类
public	可以	可以	可以【能继承】	可以【能继承】	可以
缺省的	可以	可以	可以【能继承】	不可以	不可以
protected	可以	可以	可以【能继承】	可以【能继承】	不可以
private	可以	不可以	不可以	不可以	不可以

例1：测试同一个类中，四种修饰符修饰的变量能否被访问

public class TextClass {

//类中变量--public【公共的】  缺省的【友好的】  protected【受保护的】 private【私有的】

      public String publicname="公共的";

      String queshengname="缺省的";

      protected String proname="受保护的";

      private String privatename="私有的";



   public void testMethod(){

            System.out.println("publicname="+publicname);

            System.out.println("queshengname="+queshengname);

            System.out.println("proname="+proname);

            System.out.println("privatename="+privatename);

}

}

测试类：

public class TextMain4 {

      public static void main(String[] args) {

            TextClass tc1=new TextClass();

            tc1.testMethod();

      }

}

输出：

publicname=公共的

queshengname=缺省的

proname=受保护的

privatename=私有的

结论1：同一个类中，四种修饰符修饰的变量可以被访问

例2：测试同一个包中的其他非子类，四种修饰符修饰的变量能否被访问

public class OtherClass {

      public void testMethod1(){

            TextClass tc=new TextClass();

            System.out.println("publicname="+tc.publicname);

            System.out.println("queshengname="+tc.queshengname);

            System.out.println("proname="+tc.proname);

            //System.out.println("privatename="+tc.privatename);报错

      }

}

例3：测试同一个包中的子类，四种修饰符修饰的变量能否被访问

public class TextSonClass extends TextClass{

      public void testMethod(){

            System.out.println("publicname="+publicname);

            System.out.println("queshengname="+queshengname);

            System.out.println("proname="+proname);

            //System.out.println("privatename="+privatename);报错

      }

}

结论2：同一个包中其他类，只有private修饰的变量不可以被访问

例4：测试不同包中的子类，四种修饰符修饰的变量能否被访问

import com.weiwei.test4.TestClass;

public class TestSonClass extends TestClass{

      public void testMethod(){

            System.out.println("publicname="+publicname);

            //System.out.println("queshengname="+queshengname);报错

            System.out.println("proname="+proname);

            //System.out.println("privatename="+privatename);报错

      }

}

结论3：不同包中子类，缺省的和private修饰的变量不可以被访问

例5：测试不同包中的非子类，四种修饰符修饰的变量能否被访问

import com.weiwei.test4.TestClass;

public class OtherClass {

      public void testMethod(){

            TestClass tc=new TestClass();

            System.out.println("publicname="+tc.publicname);

            //System.out.println("queshengname="+tc.queshengname);报错

            //System.out.println("proname="+tc.proname);报错

            //System.out.println("privatename="+tc.privatename);报错

      }

}

结论4：不同包中非子类，只有public修饰的变量可以被访问

2.7 java中子类的继承性

（1）java中的类是单继承，一个java类只能继承一个父类。

（2）同一个包中的子类可以继承父类中除private修饰之外的变量或方法。

（3）不同包中的可以继承父类中public和protected修饰的变量和方法。

（4）子类中的变量和方法，有一部分是子类从父类继承的，还有一部分是子类自己创建。

（5）定义的java类如果没有明确的继承某个类，那么这个类默认继承了java.lang.Object类。

2.8 成员变量的隐藏

（1）在同一个类中，局部变量的名称与某一个成员变量的名称相同，那么成员变量会被隐藏，需要强制使用被隐藏的成员变量，this访问。

例：

import com.weiwei.test4.TestClass;

public class OtherClass {

      public void testMethod(){

            TestClass tc=new TestClass();

            System.out.println("publicname="+tc.publicname);

            //System.out.println("queshengname="+tc.queshengname);报错

            //System.out.println("proname="+tc.proname);报错

            //System.out.println("privatename="+tc.privatename);报错

      }

}

（2）在子类中的某一个成员变量的名称与父类某一个成员变量的名称相同, 那么父类成员变量会被隐藏，需要强制使用被隐藏的父类成员变量，super访问。

例：

//父类

public class Person {

      //成员变量

      public String name="zhangsan";

}



//子类

public class Student extends Person{

      public char name='好';

      public void method(){

            System.out.println("name=="+name);//好

            System.out.println("name=="+super.name);//zhangsan

      }

}

测试类：

public class Main {

      public static void main(String[] args) {

            Student st=new Student();

            System.out.println("name=="+st.name);

            st.method();

      }

}

输出：

name==好

name==zhangsan

2.9 方法重写

在子类中某一个方法（包括名称，返回值，参数）与父类中的某一个方法相同，此时就是子类重写父类的方法。

例：

public class Person {

      public  void  testInfo(){

            System.out.println("Person的实例方法");

      }

}

public class SunClass extends Person{

      //方法重写

      public void  testInfo(){

         System.out.println("SunClass的实例方法");

      }

}

输出为：SunClass的实例方法

2.10 方法重写和方法重载区别

方法重载	方法重写
同一个类中	子类中
方法名称相同	方法名称相同
方法参数不同	方法参数相同
与返回值无关	方法返回值类型相同
	强制使用被重写的父类方法super.方法