第五天---面向对象进阶

最新推荐文章于 2024-09-16 20:08:29 发布
最新推荐文章于 2024-09-16 20:08:29 发布
阅读量169 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/impossiblezZ/article/details/107903545
版权

instanceof 运算符

public class Test{
    public static void main(String[] args) {
        Student s = new Student("张三",172,"Java");
        System.out.println(s instanceof Person);
        System.out.println(s instanceof Student);
    }
}

//两条语句的输出结果都是true。

 Object类的基本特性

  Object类是所有Java类的根基类，也就意味着所有的Java对象都拥有Object类的属性和方法。如果在类的声明中未使用extends关键字指明其父类，则默认继承Object类。

public class Person {
    ...
}
//等价于：
public class Person extends Object {
    ...
}

 ==和equals方法

“==”代表比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。  

 Object类中定义有：public boolean equals(Object obj)方法，提供定义“对象内容相等”的逻辑。比如，我们在公安系统中认为id相同的人就是同一个人、学籍系统中认为学号相同的人就是同一个人。  

 Object 的 equals 方法默认就是比较两个对象的hashcode，是同一个对象的引用时返回 true 否则返回 false。但是，我们可以根据我们自己的要求重写equals方法。

super关键字 

public class TestSuper01 { 
    public static void main(String[] args) {
        new ChildClass().f();
    }
}
class FatherClass {
    public int value;
    public void f(){
        value = 100;
        System.out.println ("FatherClass.value="+value);
    }
}
class ChildClass extends FatherClass {
    public int value;
    public void f() {
        super.f();  //调用父类对象的普通方法
        value = 200;
        System.out.println("ChildClass.value="+value);
        System.out.println(value);
        System.out.println(super.value); //调用父类对象的成员变量
    }
}

  super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。

使用super调用普通方法，语句没有位置限制，可以在子类中随便调用。

若是构造方法的第一行代码没有显式的调用super(...)或者this(...);那么Java默认都会调用super(),含义是调用父类的无参数构造方法。这里的super()可以省略。

封装

class Person {
    private String name;
    private int age;
    public Person() {
 
    }
    public Person(String name, int age) {
        this.name = name;
        // this.age = age;//构造方法中不能直接赋值，应该调用setAge方法
        setAge(age);
    }
     
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        //在赋值之前先判断年龄是否合法
        if (age > 130 || age < 0) {
            this.age = 18;//不合法赋默认值18
        } else {
            this.age = age;//合法才能赋值给属性age
        }
    }
    public int getAge() {
        return age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}
 
public class Test2 {
    public static void main(String[] args) {
        Person p1 = new Person();
        //p1.name = "小红"; //编译错误
        //p1.age = -45;  //编译错误
        p1.setName("小红");
        p1.setAge(-45);
        System.out.println(p1);
         
        Person p2 = new Person("小白", 300);
        System.out.println(p2);
    }
}

编程中封装的具体优点：

1. 提高代码的安全性。

2. 提高代码的复用性。

3. “高内聚”：封装细节，便于修改内部代码，提高可维护性。

4. “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。

访问控制符 

1. private 表示私有，只有自己类能访问

2. default表示没有修饰符修饰，只有同一个包的类能访问

3. protected表示可以被同一个包的类以及其他包中的子类访问

4. public表示可以被该项目的所有包中的所有类访问

多态(polymorphism) 

class Animal {
    public void shout() {
        System.out.println("叫了一声！");
    }
}
class Dog extends Animal {
    public void shout() {
        System.out.println("旺旺旺！");
    }
    public void seeDoor() {
        System.out.println("看门中....");
    }
}
class Cat extends Animal {
    public void shout() {
        System.out.println("喵喵喵喵！");
    }
}
public class TestPolym {
    public static void main(String[] args) {
        Animal a1 = new Cat(); // 向上可以自动转型
        //传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
        animalCry(a1);
        Animal a2 = new Dog();
        animalCry(a2);//a2为编译类型，Dog对象才是运行时类型。	
         
        //编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。
        // 否则通不过编译器的检查。
        Dog dog = (Dog)a2;//向下需要强制类型转换
        dog.seeDoor();

        //最后写向下转型的问题
        Animal c = new Cat();
        Dog1 d3 = (Dog1) c;
        d3.seeDoor();
    }
 
    // 有了多态，只需要让增加的这个类继承Animal类就可以了。
    static void animalCry(Animal a) {
        a.shout();
    }
 
    /* 如果没有多态，我们这里需要写很多重载的方法。
     * 每增加一种动物，就需要重载一种动物的喊叫方法。非常麻烦。
    static void animalCry(Dog d) {
        d.shout();
    }
    static void animalCry(Cat c) {
        c.shout();
    }*/
}

   多态的要点：

1. 多态是方法的多态，不是属性的多态(多态与属性无关)。

2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。

3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法

 对象的转型casting

public class TestCasting {
	public static void main(String[] args) {
		Object obj = new String("这是测试");//向上可以自动转型
		//obj.charAt(0) 无法调用。编译器认为obj是Object类型而不是String类型
		//编译程序时，如果想要调用运行时类型的方法，只能进行强制类型转换。不然通不过编译器的检查
		String str = (String) obj;//向下转型
		System.out.println(str.charAt(3));//位于0索引位置的字符
		System.out.println(obj == str);//true。他们俩运行时是同一个对象
	}

}
public class TestCasting2 {
	public static void main(String[] args) {
		Object obj = new String("乘风破浪");
		//真实的子类类型是String。但是此处向下转换类型为StringBuffer
		StringBuffer str =(StringBuffer) obj;
		System.out.println(str.charAt(0));
	}

}
public class TestCasting3 {
	public static void main(String[] args) {
		Object obj = new String("乘风破浪");
		if (obj instanceof String) {
			String str = (String) obj;
			System.out.println(str.charAt(0));
		}else if (obj instanceof StringBuffer) {
			StringBuffer str = (StringBuffer) obj;
			System.out.println(str.charAt(0));
		}
	}

}

final关键字

1. 修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。

final  int   MAX_SPEED = 120;

2. 修饰方法：该方法不可被子类重写。但是可以被重载!

final  void  study(){}

3. 修饰类: 修饰的类不能被继承。比如：Math、String等。

final   class  A {}

抽象方法和抽象类

抽象类的使用要点:

1. 有抽象方法的类只能定义成抽象类

2. 抽象类不能实例化，即不能用new来实例化抽象类。

3. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。

4. 抽象类只能用来被继承。

5. 抽象方法必须被子类实现

接口

声明格式：

[访问修饰符]  interface 接口名   [extends  父接口1，父接口2…]  {

常量定义； 

方法定义；

}

定义接口的详细说明：

1. 访问修饰符：只能是public或默认。

2. 接口名：和类名采用相同命名机制。

3. extends：接口可以多继承。

4. 常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。

5. 方法：接口中的方法只能是：public abstract。 省略的话，也是public abstract。

public class TestInterface {
	public static void main(String[] args) {
		Volant volant  = new Angel();
		volant.fly();
		System.out.println(volant.FLY_HIGHT);
		
		Honest honest = new GoodMan();
		honest.helpOther();
		Volant volant2 = new SpiderMan();
		volant2.fly();
	}

}
//飞行接口
interface Volant  {
	int FLY_HIGHT = 100;//总是public static final类型的；
	void fly();//总是public abstractvoid fly()
	
}
interface Honest {
	void helpOther();
	
}
//Angle类实现飞行接口和善良接口
class Angel implements Volant,Honest {
	public void fly() {
		System.out.println("我是天使，飞起来了");
	}
	public void helpOther() {
		System.out.println("扶老奶奶过马路");
	}
}
class GoodMan implements Honest {
	public void helpOther() {
		System.out.println("好人，扶老奶奶过马路");
	}
}
class SpiderMan implements Volant {
	public void fly() {
		System.out.println("我是蜘蛛侠，在飞");
	}
}

内部类

/**外部类Outer*/
class Outer {
    private int age = 10;
    public void show(){
        System.out.println(age);//10
    }
    /**内部类Inner*/
    public class Inner {
        //内部类中可以声明与外部类同名的属性与方法
        private int age = 20;
        public void show(){
            System.out.println(age);//20
        }
    }
}

内部类的作用：

1. 内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。

2. 内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。 但外部类不能访问内部类的内部属性。

3. 接口只是解决了多重继承的部分问题，而内部类使得多重继承的解决方案变得更加完整。

String类

 

1. String类又称作不可变字符序列。

   2. String位于java.lang包中，Java程序默认导入java.lang包下的所有类。

public class StringTest1 {
    public static void main(String[] args) {
        String s1 = "core Java";
        String s2 = "Core Java";
        System.out.println(s1.charAt(3));//提取下标为3的字符
        System.out.println(s2.length());//字符串的长度
        System.out.println(s1.equals(s2));//比较两个字符串是否相等
        System.out.println(s1.equalsIgnoreCase(s2));//比较两个字符串（忽略大小写）
        System.out.println(s1.indexOf("Java"));//字符串s1中是否包含Java
        System.out.println(s1.indexOf("apple"));//字符串s1中是否包含apple
        String s = s1.replace(' ', '&');//将s1中的空格替换成&
        System.out.println("result is :" + s);
    }
}
public class StringTest2 {
    public static void main(String[] args) {
        String s = "";
        String s1 = "How are you?";
        System.out.println(s1.startsWith("How"));//是否以How开头
        System.out.println(s1.endsWith("you"));//是否以you结尾
        s = s1.substring(4);//提取子字符串：从下标为4的开始到字符串结尾为止
        System.out.println(s);
        s = s1.substring(4, 7);//提取子字符串：下标[4, 7) 不包括7
        System.out.println(s);
        s = s1.toLowerCase();//转小写
        System.out.println(s);
        s = s1.toUpperCase();//转大写
        System.out.println(s);
        String s2 = "  How old are you!! ";
        s = s2.trim();//去除字符串首尾的空格。注意：中间的空格不能去除
        System.out.println(s);
        System.out.println(s2);//因为String是不可变字符串，所以s2不变
    }
}

字符串相等判断

1. equals方法用来检测两个字符串内容是否相等。如果字符串s和t内容相等，则s.equals(t)返回true，否则返回false。

2. 要测试两个字符串除了大小写区别外是否是相等的，需要使用equalsIgnoreCase方法。

3. 判断字符串是否相等不要使用"=="。

 

 

impossiblezZ
关注
2、面向对象
AnMixiu的博客
02-08 493
面向对象 面向过程和面向对象 面向过程(Procedure Oriented)和面向对象(Object Oriented,OO)都是对软件分析、设计和开发的一种思想,它指导着人们以不同的方式去分析、设计和开发软件。 早期先有面向过程思想，随着软件规模的扩大，问题复杂性的提高，面向过程的弊端越来越明显的显示出来，出现了面向对象思想并成为目前主流的方式。 两者都贯穿于软件分析、设计和开发各个阶段，对应...
PHP5面向对象开发教程第二章-PHP5面向对象进阶
03-15
本教程将深入探讨PHP5的面向对象特性，帮助开发者从基础过渡到进阶阶段。 首先，我们要理解PHP5中的类与对象。类是创建对象的蓝图，它定义了属性（variables）和方法（functions）。例如，你可以创建一个名为...
第五天-面向对象（变量，封装，构造函数，this）
yellowchow的专栏
07-26 546
Java面向对象 3、面向对象 3.1面向对象概念 3.1.1理解面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程：强调的是功能行为 面向对象：将功能封装进对象，强调具备功能的对象。 面向对象是基于面向过程的。 3.1.2面向对象的特点 面向对象三个特征：封装，继承，多态。 开发：其实就是找对象使用，没有对象，就创建对象。 面向对象特点
Java第五天-面向对象
qq_34343249的博客
12-07 149
一：面向对象思想的落地法则 1.设计类，并设计类的成员（成员变量和方法） 通过类,来创建类的对象（类的实例化） 3.通过“对象.属性”或“对象.方法”来调用，完成相应的功能 二：创建的多个对象 。彼此互不干扰，各自拥有一套类的属性 三:类的属性（成员变量） 成员变量 VS 局部变量 相同点：1.遵循变量声明的格式：数据类型 变量名 = 初始化值 2.有自己的作用范围（作用域） 不同...
5.4 jmu-Java-04面向对象进阶-04-嵌套类-静态嵌套类
weixin_73533788的博客
11-05 326
定义类，在该类内部创建一个静态嵌套类，该嵌套类包含：与，用于存放最小值最大值toString方法，格式见下面的输出样例。为类创建一个静态方法，对传递进来的数组找到其中的最大值和最小值并返回对象。PairResultmain方法说明输入样例输出样例思路：类方法：首先定义一个静态嵌套类PairResult，它有两个属性min和max，用于存储最小值和最大值（赋值为数组的第一个数值以防数组只有一个时报错）。然后定义了一个toString方法，用于将对象转换为字符串。
java面向对象进阶进阶篇--《包和final》
2302_80329073的博客
07-23 1557
在类级别定义常量时，通常使用关键字组合。这种方式定义的常量在整个类的生命周期内只有一个副本，所有实例共享。这样定义的常量可以通过和访问。
java学习---面向对象进阶
MTYSYS19990212的博客
08-03 1918
面向对象进阶1、权限访问  1.1 封装对象  1.2 权限修饰符2、代码块 2.1 普通代码块 2.2 构造代码块 2.3 静态代码块3、当前对象和父类对象的访问 3.1 this（当前对象） 3.2 super（父类对象）4、包 4.1 包的含义 4.2 包的使用 4.3 import 关键字5、入口方法详解 1、权限访问   1.1 封装对象      
Python语法进阶学习--面向对象
Yan_bigdata的博客
01-15 1021
1- 我们进行类的定义、方法的定义，这些操作，都称之为封装2- 封装里面的私有权限，用来对外部屏蔽类内部的底层细节，不对外暴露3- 分为私有属性和私有方法。命名的时候在前面使用两个下划线__，用来表示私有4- 私有属性和方法，正常只能在类的内部访问5- 私有属性和方法，可以通过保留方式在类的外部访问。也就是 实例对象名称._类名__私有属性和方法。该方式不推荐1- 继承：子类从父类中获得相关的方法和属性，该过程称之为继承。不能继承私有属性和方法2- 继承分类：单继承、多继承、多层继承。
学Python的漫画漫步进阶 -- 第九步.类与对象
华为奋斗者精神
09-15 3946
在Python中，类是创建对象的蓝图或模板，而对象是类的实例。我们可以自定义类，即创建一种新的数据类型。Python中类的定义语法格式如右图所示。定义小汽车（Car）类的代码如下：小汽车（Car）类继承了object类，object类是所有类的根类，在Python中任何一个类（除object外）都直接或间接地继承了object，直接继承object时（object）部分的代码可以省略。在Python编程中，类（Class）和对象（Object）是非常基础且重要的概念。
PHP----进阶知识----面向对象
July_1988的博客
10-29 198
本文主要记录一些自己学习过程中遇到的进阶知识，仅做参考。
java面向对象---多态（基础进阶篇）
2301_80068745的博客
08-09 869
说白了，就是对象的多种形态。
Python计划. 面向对象语法精讲面. 面向对象进阶-对象的引用.pdf
05-19
面向对象编程是Python的核心特性之一，它通过类（class）和对象（object）来组织代码，使得程序设计更加模块化和可复用。在Python中，对象是数据和相关操作的封装体，而引用则是指向对象内存地址的指针。本篇将深入...
Python面向对象进阶教程,Python面向对象进阶知识笔记.doc
10-01
本文将深入探讨Python面向对象编程的进阶知识，包括类方法、静态方法、`__new__`和`__init__`方法以及单例模式。 1. **类方法**： 类方法是通过装饰器`@classmethod`标识的方法，它们的第一个参数通常是`cls`，...
python-基础-进阶-高级的讲义
02-15
5. **面向对象编程**：了解类的定义、对象的创建，以及继承、封装和多态等概念。 ### Python进阶 进阶部分将深入探讨： 1. **文件操作**：学习读写文件、追加内容、文件处理异常等技巧。 2. **正则表达式**：...
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1108
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 151
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 914
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 342
spirng security中的几大组件的差异和执行顺序
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
最新发布
weixin_19164791635
09-16 587
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
Objective-C编程指南：从基础到进阶
5. **第五章 - 对象的初始化** - 在Objective-C中，对象的创建和初始化过程，包括使用`alloc`、`init`方法和构造函数。 6. **第六章 - 存取器** - 存取器（accessors）是封装对象属性的方法，包括getter和setter...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值