Java语言入门（六）——面向对象（三）

最新推荐文章于 2024-05-21 22:13:42 发布
最新推荐文章于 2024-05-21 22:13:42 发布
阅读量187 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45854582/article/details/106136423
版权

Java语言入门

程序代码块

1 普通代码块（一般写在普通方法里）
2 构造代码块（直接在类中定义的代码块，可以看成是一个类的成员，它会被调用多次，并比构造方法先执行）
3 静态代码块（在一般类里，或者是在启动类里，每个静态块只执行一次）
4 同步代码块（多线程中应用）
5 Tips：静态块先于主方法执行，静态块先于普通块执行，静态块也先于构造块执行。

class Person
{ void f( )
  {  if (true)
     {     /*普通代码块*/
          int x=10;
          System.out.println(x);
      }
      int x=12;}
}
class Test-6.1
{  public static void main(String[] args)
   {System.out.println( );  }
}

class Person
{   String name;
    public Person()
    {  System.out.println("this is a gouzao fangfa");  }
    {   /*比构造方法先执行，并且是多次执行（每生成一个对象就执行一次）*/
     System.out.println("this is a gouzao code");
    } 
}
class Test-6.2
{   public static void main(String[] args)
    {  new Person();
       new Person();
       System.out.println();
     }
}

class Person
{   String name;
    public Person()
    {  System.out.println("this is a gouzao fangfa");  }
    {  System.out.println("&&&&&this is a gouzao code");}
    static
    {  System.out.println("^^^^this is a jingtai code");  }
    /*静态块，在构造块前加上static，比构造块和构造方法先执行，并且只执行一次*/
}
class Test-6.3
{   public static void main(String[] args)
    {  new Person();
       new Person();
       System.out.println(); }
}

class Person
{   String name;
    public Person()
    {  System.out.println("this is a gouzao fangfa");  }
}
class Test-6.4
{   public static void main(String[] args)
    {  System.out.println("begin");
       new Person();
       new Person();
       System.out.println("end"); }
     static
    {  System.out.println("this is a jingtai  QiDong code");  }
/*可用于静态变量初始化,主类中的静态方法块比main方法还先执行,且位置不影响运行顺序*/
}

class Test-6.5
{
     static 
     {
         System.out.println("I am here!");
         System.exit(1); 
      }
}
//不用主方法就能输出I am here!
/*强行退出系统，这样不需执行main()也不会出现异常,若没System.exit(1);输出static内容后，提示出错。少用，尽量有main()*/

内部类（内置类）

1 成员内部类（实例内部类）：可以访问外部类的成员（包括私有的）;外部类不能直接访问内部类成员变量，必须构造方法修改
2 静态内部类（相当于外部类）
3 局部内部类（方法里）
4 匿名内部类（一般是在抽象类和接口的基础上使用）

class Outter
{   String name="huang";
    //class Inner {  System.out.println(name);  }错误
    class Inner
    {   String name="guo";    //变量的就近原则
        public void f( )   { System.out.println(name); }   //运行结果：guo
    }                                                      //生成的文件目录：
     public void print( )                                  //Outter.class
     {   Inner  in = new Inner( );     in.f( );  }         //Test-6.6.class
}                                                          //Outter$Inner.class
class Test-6.6
{   public static void main(String[] args)
    {  Outter out = new Outter( );    out.print( );  }
}

class Outter
{   private String name="huang";
    class Inner
    {   String name ="guo";
        public void f( )   
        { System.out.println(name);                 //guo
          System.out.println(Outter.this.name); }   //huang
    }
     public void print( ) 
     {   Inner  in = new Inner( );     in.f( );  }  }
class Test-6.7
{   public static void main(String[] args)
    {  Outter out = new Outter( );   out.print( );
    //Outter.Inner in = new Outter.Inner( );   in.f( );错误
} }

class Outter
{   private String name="huang"; //封装后内部类可直接访问
    class Inner
    {   String name ="guo";
        public void f( )   { System.out.println(name);}  }     //guo
     public void print( ) 
     {   Inner  in = new Inner( );     in.f( );  }  }
class Test-6.8
{   public static void main(String[] args)
    {  Outter out = new Outter( );  
       Outter.Inner in = out.new Inner(); 
       in.f( );
    /*等价于Outter.Inner in = new Outter().new Inner();
        in.f( );*/
} }

class Outter
{   private String name="huang"; 
    static class Inner
    {   String name ="guo";
         public void f( )   { System.out.println(name);}     //guo
     }
     public void print( ) 
     {   Inner  in = new Inner( );     in.f( );  }  
}
class Test-6.9
{   public static void main(String[] args)
    {   Outter.Inner in = new Outter.Inner( );  
         in.f( );
    }
 }

class Outter
{   private String name="huang"; 
    public void print( ) 
     {    class Inner
          {   String name ="guo";
               public void f( )   { System.out.println(name);}  //运行结果：guo
           }
           Inner  in = new Inner( );     in.f( );        //生成的文件目录：
      }                                                  //Outter.class
}                                                        //Test-6.10.class
class Test-6.10                                          //Outter$Inner.class
{   public static void main(String[] args)
    {  Outter out = new Outter( );    
        out.print( ); }
 }

class Outter
{   private String name="huang"; 
    public void print( ) 
     {    final String name="guo"; //一定要初始化
          class Inner
          {  public void f( )   { System.out.println(name);  }  }
/*不加final就写成System.out.println(Outter.this.name);*/
           Inner  in = new Inner( );     in.f( );  
    }  
}
class Test-6.11
{   public static void main(String[] args)
    {  Outter out = new Outter( );     out.print( ); }     //guo
 }

在这里插入图片描述

继承（extends）

1 Java只支持单继承，不允许多重继承（一个子类只能有一个父类）。但支持多层继承（传递性）
2 在生成子类对象之前，一定先生成父类对象
3 子类内存一定比父类内存大
4 子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法。子类实例化时，先调用父类的构造方法，再调用自己的构造方法（子类构造方法中隐藏一个super()方法，用于调用父类的构造方法）

class Person
{  String name;  
    private int age; //隐式继承,不能直接访问,可通过方法调用
    public void setName(String name)
    {  this.name=name;  }
    public void setAge(int age) //显式的继承
    {  this.age=age;  }
    public String getName()  { return this.name; }
    public int getAge()  { return this.age; } 
}
class Student extends Person
{   private String school;
    public void setSchool(String school) 
    {  this.school=school;  }
    public String getSchool()  {  return this.school; }
}
class Test-6.12
{
    public static void main(String[] args)
    {
       Student s=new Student();
       s.name="LJS";
       //s.age=3; 错误
       s.setAge(3);
       System.out.println(s.getName());      //LJS
       System.out.println(s.getAge());       //3
     }
}

在这里插入图片描述

lass Person
{   private String name;  
    Person()   { System.out.println("##i am a father##"); //}     
    Person(String name)  
    {   this.name=name;  
        System.out.println(name);
        System.out.println("$$i am a father$$");  }
    public void setName(String name) { this.name=name; }
    public String getName()  { return this.name; }
}
class Student extends Person
{   String school="GDPU";
     Student()  
    {   super("LL");   System.out.println("**i am a son**"); } 
}
class Test-6.13
{
    public static void main(String[] args)       //运行结果：
    {                                            //LL
       Student s=new Student();                  //$$i am a father$$
       s.setName("LJS");                         //**i am a son**
       System.out.println(s.getName());          //LJS
     }
}
/*Student类中默认的构造方法是Student(){super();}
  Super()的作用是子类调用父类的构造方法

super关键字

1 调用父类的构造（super() , this()），都必须放在第一行 。this（）和super（）不能写在一起
2 可以调用父类的成员（成员变量+成员方法）（ super.x 或者 super.a( ) )
3 子类内存一定比父类内存大

lass  A
{  int age;
    public A(int age)
    {  System.out.println("^^^AA^^^"); }
}	
class B extends A
{   public B()
    {   super(10);
         System.out.println("****BB*****");}
}
class C extends B
{    public C()
     {   super();
          System.out.println("&&&CC&&&&");}
}
class Test-6.14
{
    public static void main(String[] args)
    {
        System.out.println();
        C c=new C();
     }
}

//问，产生多少个对象？？
//一个字符串常量就是一个匿名对象

class A
{  public A()//调用顺序2
    {  System.out.println("^^^AA^^^");  }
}	
class B extends A
{   public B()
     {  this(1);  //调用顺序1
         //super();
         System.out.println("****BB*****"); //调用顺序4
      }  
       public B(int x) //调用顺序1
       {  //super();默认，调用顺序2
           System.out.println("********");//调用顺序3
       }
}
class Test-6.15
{   public static void main(String[] args)   //^^^AA^^^
    {   B b=new B();                         //********
        System.out.println();                //****BB*****
     }
}

class A
{  int age=10;
   public A()	{ System.out.println("^^^AA^^^"); }
   public void print()   {System.out.println(age);}
}
class B extends A
{  int age=20;
   public B()	{  System.out.println("***BB***"); }
}
class Test-6.16
{  public static void main(String[] args)       //^^^AA^^^
    {  B b=new B();                             //***BB***
        b.print();                              //10
     }
}

class A
{  int age=10;
   public A()	{ System.out.println("^^^AA^^^"); }
}
class B extends A
{  int age=20;
   public B()	{  System.out.println("***BB***"); }
   public void print()   {System.out.println(age);}
}
class Test-6.17
{  public static void main(String[] args)        //^^^AA^^^
    {  B b=new B();                              //***BB***
        b.print();                               //20
     }
}

class A
{  int age=10;
   public A()	{ System.out.println("^^^AA^^^"); }
}
class B extends A
{  int age=20;
   public B()	{  System.out.println("***BB***"); }
   public void print()   {System.out.println(super.age);}
}
class Test-6.18
{  public static void main(String[] args)     //^^^AA^^^
    {  B b=new B();                           //***BB***
        b.print();                            //10
     }
}

在这里插入图片描述

方法的改写

1 又名：重写/覆写/覆盖 override
2 方法的头完全相同，方法体不同（一定要发生在继承中的父类和子类之间）
3 当子类改写了父类的方法成功之后，当生成子类对象，调用的一定是子类改写过的方法
4 子类改写父类的方法时，子类的访问权限不能比父类更严格（private > default(friends) > public )
5 如果父类的方法是私有的，则不能被改写

class A
{  public void print()
   {  System.out.println("%%%%father");}	
}
class B extends A
{   public void print()
    {  System.out.println("%%%%child%%%%");}
}
class Test-6.19
{
   public static void main(String[] args)
    {   B b=new B();
         b.print();           //%%%child%%%
   }
}

class A
{  void print()
   {  System.out.println("%%%%father");}	
}
class B extends A
{   public void print()
    {  System.out.println("%%%%child%%%%");}
}/*若换成拿掉B类的public，则错误*/
class Test-6.20
{
   public static void main(String[] args)
    {   B b=new B();
         b.print();          //%%%%child%%%
   }
}

class Person
{  public void f()  { say();  /*也可为this.say();*/  }    
   public void say()
   { System.out.println("father"); }
}
class Student extends Person
{  public void say()
   { System.out.println("student"); }
}
class Test-6.21
{  public static void main(String[] args)
   {   Student s=new Student();
       s.f();               //student
    }
} //间接调用

class Person
{  public void f()  { say();}    
   private void say()
   { System.out.println("father"); }
}
class Student extends Person
{  public void say()
   { System.out.println("student"); }
}
class Test-6.22
{  public static void main(String[] args)
   {   Student s=new Student();
       s.f();                //father
    }
}

final关键字

1 修饰类，不能有子类（此时为最终类）
2 修饰方法，不能被子类改写
3 修饰成员变量，成为一个常量,不能被修改。(大写) 使用public static final声明的常量称为全局常量
4 final可以修饰非抽象类，非抽象成员方法和变量，但不能用来修饰构造方法。
5 注意：形参调用内部类，则形参前必须有final修饰

final class A //最终类
{  
    final int x=10;//变为常量
    public static final int Y=10;//变为全局常量，,全局常量名应大写
    public final void f(){ } //最终方法
}
/*class B extends A
{
    //public void f()  {x=100;}错误
}*/
class Test-6.23
{  public static void main(String[] args)
    { System.out.println(); }
}

对象转型

前提：一般发生在继承中
1 向上转型：父类的引用指向子类对象（小的赋给大,是系统自动）（隐式）（常用） 只能执行父类自己所拥有的成员
2 向下转型：不可直接向下转型，必须先发生向上的转型 （少用）
3 instanceof 作用: 判定对象是不是父类,子类的对象

class A
{       }
class B extends A
{       }
class Test-6.24
{   
     public static void main(String[] args)
     {
         //A a=new A();
         A a=new B();   //儿子赋给父亲  向上转型，自动
         System.out.println();
      }
}
//向上转型,父类的引用指向子类对象

class A
{       }
class B extends A
{       }
class Test-6.25
{  public static void main(String[] args)
   {
     //B b=new A();  错误,父类生成时,无法知道子类
      A a=new B();
      B b=(B)a;//把父类类型赋予子类需要强制类型转换，显式}
}
//向下转型

class A
{ public void say()
  {System.out.println("father");}
}
class B extends A
{ String xiaomi = "5splus";
  public void say()  {System.out.println("son");}
  public void play()  {System.out.println("play");}
}
class Test-6.26
{ public static void main(String[] args)
  { A a=new B(); //把儿子看成父亲，实为儿子
    System.out.println(a.xiaomi); //错误,子类独有,父亲无法代表
  }
} //父类可代表子类，但实际运行权限仅限于父类范围
Bella冲呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA-SE入门学习——第六讲面向对象进阶
06-08
JAVA入门学习——第六讲面向对象进阶
【黑马程序员】《Java基础入门》——02 面向对象
你若盛开，清风自来。
03-10 7242
1 方法的初始化 1.1 类的基本概念 （1）属性：描述对象的特征（C++中的数据成员） （2）方法：描述对象的行为（C++中的成员函数） （3）类的内容：①成员变量 ②成员方法 ③成员内部类（Java特性） 1.2 成员变量的默认值 PS：Java的成员变量可以在类中进行初始化（C++不行） 1.3 ...
小白零基础快速入门Java —— 第八课：面向对象高级篇 —— 面向对象三大特征之二：继承
Huacyu的博客
12-02 35
小白零基础快速入门Java —— 第八课：面向对象高级篇 —— 面向对象三大特征之二：继承。本文介绍了以下内容：1、继承的快速入门。2、继承的相关注意事项。包括：单继承、object类、方法重写、子类中访问其他成员的特点、子类构造器的特点和权限修饰符等。
IDEA入门实录——面向对象的三个阶段（创建对象）
m0_68519425的博客
03-24 114
承接上一篇（IDEA入门实录——面向对象的三个阶段）的例子，继续创建对象，创建一个新的测试类，然后根据下面例子进行练习。
小白零基础快速入门Java —— 第六课：面向对象基础
Huacyu的博客
11-30 22
小白零基础快速入门Java —— 第六课：面向对象基础。本文介绍了一下内容：1、面向对象编程快速入门。2、对象在计算机中的执行原理。3、类和对象的一些注意事项。4、this关键字。5、构造器。6、封装。7、实体类JavaBean。 8、面向对象编程综合案例。9、补充知识：成员变量、局部变量的区别。
educoder——面向对象程序设计java——第一阶段java语言基础（一）——java初体验
zj5566778899的博客
01-19 3658
第1关：Java第一课 编程要求 是否能独立的写出一个Java程序了呢？在右侧编辑器中编写代码输出如下结果： 第2关：Java入门测试题 1、 Java源代码文件的扩展名为（ C） A、 .txt B、 .class C、 .java D、 .doc 2、 在控制台显示消息的语句正确的是（ C） A、 System.out.println(我是一个Java程序员了！); B、 System.Out.Println("我是一个Ja.
java入门须知——零基础，初学入门
04-28
零基础学习java语言，次内容只包含java语言的基础，入门必懂 包括： java介绍 java环境搭建 基础语法和语言结构
java经典入门教程——自学推荐
02-03
Java 是一种简单易用、完全面向对象、具有平台无关性、且安全可靠的主要面向 Internet的开发工具。自从 1995 年正式问世以来，Java 的快速发展已经让整个Web世界发生了翻天覆地的变化。随着 Java Servlet 的推出，...
Java语言实用教程1——Java快速入门
03-04
Java是一种计算机程序语言，用Java既可以编写嵌入在Web网页中运行的Java Applet小程序，也可以...Java是一个简单、面向对象、网络适用、解释型、健壮、安全、结构中立、可移植、高性能、多线程、动态的计算机程序语言。
面向对象程序设计——入门
03-04
很全面的一份入门级面向对象程序设计，内为ppt格式，系统的介绍了面向对象的思想，以及初步涉及了java语言的面向对象程序设计的做法
jar包增量更新分析
junlaiyan的专栏
05-16 320
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 677
本文主要提供用java实现的拼图小游戏源代码。
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 161
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
命令执行漏洞（二）
XLbb的博客
05-15 937
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 280
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
C++ 11
qq_65112813的博客
05-17 686
对于类类型，如果定义了接受。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1038
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
Spring6基础笔记
最新发布
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 566
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Android Model引入其他aar包 导致无法打包成aar
qq_27400335的博客
05-16 347
Android Model引入其他aar包 导致无法打包成aar
java面向对象语言
10-22
Java是一种面向对象的编程语言，它的核心思想是将现实世界中的事物抽象成对象，并通过类来描述这些对象的属性和行为。Java中的类和对象是面向对象的核心，它们提供了对创建类和创建对象简单的语法支持。Java中的类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值