java基础入门-总结（三）面向对象2

最新推荐文章于 2022-12-30 15:53:52 发布
最新推荐文章于 2022-12-30 15:53:52 发布
阅读量277 收藏 2
点赞数 1
分类专栏： 面向对象 Java 编程语言 文章标签： Java 编程语言 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Daniel_Singularity/article/details/90482342
版权
编程语言 同时被 3 个专栏收录
18 篇文章 0 订阅
订阅专栏
面向对象
11 篇文章 0 订阅
订阅专栏
Java
11 篇文章 1 订阅
订阅专栏

最近一直在追Java写博客，如有问题欢迎添加QQ：1776136546（微信同步）。

1.类的继承

关键字：extends

package st.peter.obj2;

public class Animal {

	String name;
	
	public void shout() {
		System.out.println("动物发出叫声");
	}
}

package st.peter.obj2;

public class Dog extends Animal{

	public void printName() {
		System.out.println("name="+name);
	}
}
package st.peter.obj2;

public class Demo1 {

	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.name = "哈士奇";
		dog.printName();
		dog.shout();
	}
}

子类在继承父类的时候，会自动拥有父类的所有成员。

Java中类只支持单继承，不容许多重继承。

重写：

子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。

package st.peter.obj2;

public class Animal {

	String name;
	
	public void shout() {
		System.out.println("动物发出叫声");
	}
}
package st.peter.obj2;

public class Dog extends Animal{

	//重写父类的方法
	public void shout() {
		System.out.println("汪汪汪......");
	}
}
package st.peter.obj2;

public class Demo1 {

	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.shout();
	}
}

super关键字：

super关键字用来访问父类的成员。访问父类的成员变量，成员方法和构造方法。

（1）：super关键字调用父类的成员变量和成员方法

package st.peter.obj2;

public class Animal {

	String name = "动物";
	
	public void shout() {
		System.out.println("动物发出叫声");
	}
}
package st.peter.obj2;

public class Dog extends Animal{

	String name = "犬类";
	
	//重写父类的方法
	public void shout() {
		super.shout();      //调用父类的成员方法
	}
	
	public void printName() {
		System.out.println("name="+super.name);   //调用父类的成员变量
	}
}
package st.peter.obj2;

public class Demo1 {

	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.shout();
		dog.printName();
	}
}

 

（2）：使用super关键字调用父类的构造方法

package st.peter.obj2;

public class Animal {
 
	public Animal(String name) {
		System.out.println("name="+name);
	}
}
package st.peter.obj2;

public class Dog extends Animal{

	public Dog() {
		super("hahah");
	}
}
package st.peter.obj2;

public class Demo1 {

	public static void main(String[] args) {
		Dog dog = new Dog();
	}
}

 

2.final关键字

final修饰的类不能被继承

final修饰的方法不能被子类重写

final修饰的变量是常量，只能赋值一次。

 

3.抽象类和接口

（1）抽象类

Java允许在定义方法时不写方法体，不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键字来修饰。

当一个类包含了抽象方法，该类必须使用abstract关键字来修饰。

抽象类不能用来实例化，如果想要调用抽象类中的方法，则需创建一个子类，在子类中将抽象类中的抽象方法进行实现。

package st.peter.obj2;

public abstract class Animal1 {
	
	//定义抽象方法
	abstract void shout();
}
package st.peter.obj2;

public class Dog extends Animal1{

	@Override
	void shout() {
		// TODO Auto-generated method stub
		System.out.println("汪汪汪。。。。。。");
	}
}
package st.peter.obj2;

public class Demo2 {
	
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.shout();
	}
}

 

（2）接口

接口中定义的方法默认使用“public abstract”来修饰。

接口中的变量默认使用“public static final”来修饰

需要定义一个类，通过关键字“implements”实现接口中的所有方法。

package st.peter.obj2;

public interface Ani {

	int ID = 1;
	void breathe();
	void run();
}
package st.peter.obj2;

public class Dog1 implements Ani  {

	@Override
	public void breathe() {
		System.out.println("狗在呼吸！");
		
	}

	@Override
	public void run() {
		System.out.println("狗在跑！");
	}

}

package st.peter.obj2;

public class Demo3 {

	public static void main(String[] args) {
		Dog1 dog = new Dog1();
		dog.run();
		dog.breathe();
	}
}

接口之间可以继承，可以单继承，也可以双继承。

4.多态

在同一个方法中，由于参数类型不同而导致执行效果各异的现象就是多态。

package st.peter.obj3;

public interface Animal {

	void shout();
}
package st.peter.obj3;

public class Dog implements Animal{

	@Override
	public void shout() {
		System.out.println("狗在叫......");
	}
}
package st.peter.obj3;

public class Cat implements Animal{

	@Override
	public void shout() {
		System.out.println("猫在叫......");
	}
}
package st.peter.obj3;

public class Test1 {

	public static void main(String[] args) {
		Animal a1 = new Cat();      //将Cat对象当做Animal类型来使用
		Animal a2 = new Dog();
		animalShout(a1);
		animalShout(a2);
	}
	
	public static void animalShout(Animal ani) {
		ani.shout();
	}
}

对象类型转换-强转

package st.peter.obj3;

public interface Animal {

	void shout();
}
package st.peter.obj3;

public class Dog implements Animal{

	@Override
	public void shout() {
		System.out.println("狗在叫......");
	}
	
	public void run() {
		System.out.println("狗在跑！");
	}
}
package st.peter.obj3;

public class Test1 {

	public static void main(String[] args) {
		Dog dog = new Dog();
		animalShout(dog);
	}
	
	public static void animalShout(Animal ani) {
		Dog dog = (Dog)ani;
		dog.shout();
		dog.run();
//		ani.shout();
//		ani.run();
	}
}

Java提供了一个关键字instanceof,判断一个对象是否为某个类（接口）的实例或者子类实例。

package st.peter.obj3;

public interface Animal {

	void shout();
}
package st.peter.obj3;

public class Dog implements Animal{

	@Override
	public void shout() {
		System.out.println("狗在叫......");
	}
	
	public void run() {
		System.out.println("狗在跑！");
	}
}
package st.peter.obj3;

public class Cat implements Animal{

	@Override
	public void shout() {
		System.out.println("猫在叫......");
	}
}
package st.peter.obj3;

public class Test1 {

	public static void main(String[] args) {
		//Dog dog = new Dog();
		//animalShout(dog);
		Cat cat = new Cat();
		animalShout(cat);
	}
	
	public static void animalShout(Animal ani) {
		if(ani instanceof Cat) {
			Cat cat = (Cat)ani;
			cat.shout();
		}else {
			System.out.println("是狗不能强转为猫");
		}
	}
}

Object类

他是所有类的父类，即每个类都直接或间接继承自该类

匿名内部类

匿名内部类的格式：

new 父类（参数列表）或父接口（）{

   //匿名内部类的实现部分

}

package st.peter.obj4;

public interface Animal {

	void shout();
}
package st.peter.obj4;

public class Test1 {

	public static void main(String[] args) {
		//定义匿名内部类作为参数传递给方法
		animalShout(new Animal() {

			@Override
			public void shout() {
				System.out.println("动物在叫");
			}
		});
	}
	
	public static void animalShout(Animal ani) {
		ani.shout();
	}
}

 

5.异常

语法格式如下：

try{

                    //程序代码块

}catch(ExceptionType   e){

     //对Exception的处理

}

try代码块中编写可能发生异常的Java语句。在try代码块中发生异常语句后面的代码是不会执行的。

catch代码块中编写针对异常进行处理的代码。

在程序中，有时候我们希望有些语句无论程序是否发生异常都要执行。加一个finally代码块。

package st.peter.obj4;

public class Test2 {

	public static void main(String[] args) {
		
		//try ...  catch  ...  finally 用于捕获异常
		try {
			int result = divide(4,0);
			System.out.println(result);
		}catch(Exception e) {
			System.out.println("捕获的异常信息为："+e.getMessage());
			return;   //结束当前的方法，System.out.println("程序继续向下执行");不会执行
		}finally {
			System.out.println("finally代码块。。。");
		}
		System.out.println("程序继续向下执行");
	}
	
	public static int divide(int a,int b) {
		int result = a/b;
		return result;
	}
}

throws关键字

编译时异常与运行时异常

自定义异常

6.包

import语句

7.访问控制

访问控制级别

 

 

 

 

 

 

 

 

 

 

 

凤凰AI
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java面向对象高级
Junds0的博客
01-29 865
1.重写父类抽象方法sayHello，输出打印String.format(“大家好，我叫%s，今年%d岁，很高兴认识大家”, this.name,this.age)在Java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。函数式接口代表只包含一个抽象方法的接口，函数式接口可以包含多个默认方法，类方法，但只能声明一个抽象方法。2.实现Demo接口，完善接口中的show方法，打印输出 “实现了接口中的show方法”
多态
xylyaya的博客
02-08 322
class Animal { //父类 public void shout() { System.out.println("叫了一声！"); } } class Dog extends Animal{ //子类 public void shout() { System.out.println("旺旺旺！"); } ...
创建Dog和Cat类的重写Animal父类的shout()方法，方法为输出的叫声“汪汪.....“和“喵喵….”，并在测试类中调用shout()方法，输出dog和cat的叫声。
weixin_47377116的博客
06-06 4022
package chaoxingerya; public class work02 { public static void main(String[] args) { Animal c = new Cat(); c.shout(); Animal d = new Dog(); d.shout(); } } class Animal{ public void shout(){ } } class Cat extends Animal{ @Override public void shout(){ Syst
java基础之super关键字_繁星漫天_新浪博客
weixin_42496678的博客
04-15 95
在子类重写父类的方法后，子类对象将无法访问父类被重写的方法。为了解决这个问题，java中专门提供了一个super关键字用于访问父类的成员。 1.使用super关键字来调用父类的成员变量和成员方法 例子: class Animal { String name="父类"; void shout(){ System.out.println("动物发出叫声！！！"); } } class Dog...
Java基础（六）
qq_61741696的博客
02-15 319
一.封装 封装是面向对象三大特征之一。对于程序合理的封装让外部调用更加方便，更加利于写作。同时，对于实现者来说，也更加容易修正和改版代码。 1.1 封装的具体优点： 1.提高代码的安全性。 2.提高代码的复用性。 3.“高内聚”：封装细节，便于修改内部代码，提高可维护性。 4.“低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。 1.2 封装的实现——使用访问控制符 public class person { //属性一般用private修饰 private.
完整版Java全套入门培训课件 Java基础 03-面向对象（共18页）.pptx
08-22
总结来说，Java的面向对象特性包括理解面向对象的概念、类与对象的关系、封装、构造函数的使用、this关键字的作用以及static关键字的应用。掌握这些概念对于理解和编写高质量的Java代码至关重要。通过学习这些基础...
Java基础 面向对象入门基础知识 个人学习总结
12-21
以上就是Java面向对象编程的基础知识，包括类和对象的定义、创建和使用对象、构造方法以及静态变量和静态方法的概念。理解和掌握这些基础知识是成为Java开发者的必备条件。在实践中，不断地练习和应用这些概念，才能...
Java基础入门第三版-黑马练习题
12-08
Java基础入门的学习涵盖了一系列关键概念，这里我们详细探讨一下标题和描述中提到的各个章节的知识点。 1. **Java开发入门** - **对象**：Java是一种面向对象的编程语言，一切皆对象，对象是类的实例，包含了数据...
java入门基础实验三面向对象编程.docx
12-27
java入门基础实验三面向对象编程.docx
面向对象的三大特征
qq_56751692的博客
07-24 3097
面向对象的三大特征
JAVA学习 Day07：JAVA面向对象
LIVE_SEVEN的博客
10-11 154
一、什么是面向对象OOP 属性+方法 就构成了一个类 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统，但是具体到微观操作，仍然需要面向过程的思路去处理 以类的方式组织代码，以对象的组织（封装）数据 封装、继承、多态 二、方法的加深和回顾 1.方法的定义 修饰符 返回类型 break：跳出switch，结束循环 return结束方法，返回一个结果 方法名：注意规范，见名知意 参数列表：（参数类型，参数名）… 异常抛出 package com.oop;
Java学习
m0_67308235的博客
06-09 607
Java学习
Java基础知识------面向对象(2)-中
everday learning everday dream
01-17 1801
1、继承-方法重写 1.1、重写父类方法 (override) 在继承关系中,子类会自动继承父类中定义的方法,但有时在子类中需要对继承的方法进行一些修改.即对父类的方法进行重写. 需要注意的是,在子类中重写的方法需要和父类被重写的方法具有相同的方法名,参数列表以及返回值类型. 总结 :子类重新实现父类的方法,就是方法的重写.执行的时候,如果方法被重写了,那么优先执行子类的方法. 说明 :虽然子类也拥有父类的行为.但是子类的这个行为实现方式和父类是不一样的.这个时候,子类就可以按照自己的方式重写..
Java中super关键字怎么用？
CZ-001的博客
06-04 522
当子类重写父类的方法后，子类对象将无法直接访问父类被重写的方法。为了解决这个问题，在Java中专门提供了一个super关键字来访问父类的成员，例如访问父类的成员变量、成员方法和构造方法。下面分两种情况来学习一下super关键字的具体用法。 （1）使用super关键字调用父类的成员变量和成员方法，具体格式如下： super.成员变量 super.成员方法([参数1,参数2...]) 接下来通过一个案例来学习如何使用super关键字调用父类的成员变量和成员方法，如文件1所示。 文件1 Example03.ja
Java基础5.面向对象（中）
最新发布
YW1028的博客
12-30 275
Java基础5.面向对象（中）
instanceof 关键字
yuyang_1995
06-04 1547
 Java提供了instanceof 关键字 ，它可以判断一个对象是否为某一个类（或接口）的实例或者子类的实例， 语法格式如下： 对象(或者对象的引用变量) instancesof 类(或接口)...
七：面向对象--＞继承（extends)(继承实现电子宠物系统为例)
qq_42263859的博客
06-23 1594
继承的概念、通过继承优化电子宠物系统
java继承与方法重写重载
a_passing_traveller的博客
09-25 469
继承 java使用 extends 和 implements 这两个关键字来实现继承. extends 一个子类只能拥有一个父类，只能继承一个类。 implements 可以同时继承多个接口,多个接口逗号隔开。 public class Animal { private String name; public Animal(String myName) { name = myName; } Animal() { System.out.p
JAVA day07:代码练习题（继承）
weixin_44641804的博客
08-11 9213
题目1：继承的应用 定义宠物类（ Pet ），猫类（Cat）和狗类（Dog） 1、宠物都有属性姓名（name）和年龄(age) 2、宠物都有吃（eat）、喝（drink）、叫（shout）的方法 3、猫有爬树（ climbTree ）的方法 4、狗有警戒（ police）的方法 //宠物类 public class Pet { public String name; public int age; public void eat(){ System.out.println(name+"会
Java语言程序设计入门-面向对象详解
为了辅助学习，课程提供了多本参考教材，如《Java语言程序设计》、《Java2实用教程》、《Java面向对象编程》等，鼓励学生广泛阅读并动手实践。课程采用课堂理论与实践相结合的方式，辅以课堂练习、课后练习和上机...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

凤凰AI

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值