最近一段时间看了很多的视频却忘记总结了，现在只能想到什么写什么了，希望能起到一个回忆巩固的作用。
1、final关键字
译为：最终的
final修饰的数据类型的量都是不能改变的
final修饰的类是不能被继承的
final修饰的方法在子类中是不能被重写的
package cn.bjsxt.oop.testFinal;
public /*final*/ class Animal { //final修饰类则说明，这个类不能被继承！
public /*final*/ void run(){ //final加到方法前面，意味着该方法不能被子类重写！
System.out.println("跑跑！");
}
}
class Bird extends Animal {
public void run(){
super.run();
System.out.println("我是一个小小小小鸟，飞呀飞不高");
}
}
package cn.bjsxt.oop.testFinal;
public class TestFinal {
public static void main(String[] args) {
final int MAX_VALUE= 200; //常量。
double d = Math.PI;
}
}
2、隐式参数this
java类里面的方法都有两个隐藏的参数分别是super和this，分别表示直接父类和自己类的对象。默认就加入进去了，不需要手动添加
package cn.bjsxt.oop.testThis;
public class Student {
String name;
int id;
public Student(String name,int id){
this(name); //通过this调用其他构造方法，必须位于第一句！ Constructor call must be the first statement in a constructor
this.name = name;
this.id = id;
}
//本来是这样 public Student(String name，Student this，Object super){
this.name = name;
}
public Student(){
System.out.println("构造一个对象");
}
public void setName(String name){
this.name = name;
}
public void study(){
this.name= "张三";
System.out.println(name+"在學習");
}
public void sayHello(String sname){
System.out.println(name+"向"+sname+"說：你好！");
}
}
3、Object类，Object是所有类的父类，默认就继承这个类
package cn.bjsxt.oop.testObject;
//不重写Object类的toString方法时，我们打印对象会
直接输出hash码，重写之后就返回这个字符串
public class Mobile {
public String toString(){
return "我是一部移动电话";
}
}
package cn.bjsxt.oop.testObject;
public class TestObject {
public static void main(String[] args) {
Object obj = new Object();
Object obj2 = new Object();
System.out.println(obj.toString());
System.out.println(obj2.toString());
System.out.println(obj==obj2);
System.out.println(obj.equals(obj2));
Mobile m = new Mobile();
System.out.println(m.toString());
}
}
输出：java.lang.Object@64ea66
java.lang.Object@158f9d3
false
false
我是一部移动电话
静态
package cn.bjsxt.oop.testStatic;
public class Student {
String name;
int id;
static int ss;
public static void printSS(){
System.out.println(ss);
}
public void study(){
printSS();
System.out.println(name+"在學習");
}
public void sayHello(String sname){
System.out.println(name+"向"+sname+"說：你好！");
}
}
package cn.bjsxt.oop.testStatic;
public class Test {
public static void main(String[] args) {
Student.ss = 323;
Student.printSS();
Student s1 = new Student();
}
}
静态代码块
package cn.bjsxt.oop.staticInitBlock;
public class Parent001 /*extends Object*/ {
static int aa;
static {
System.out.println(" 静态初始化Parent001");
aa=200;
}
}
package cn.bjsxt.oop.staticInitBlock;
public class TestStaticInitBlock extends Parent001 {
static int a ;
static {
System.out.println("静态初始化TestStaticInitBlock!");
a = 100;
}
public static void main(String[] args) {
}
}
静态初始化Parent001
静态初始化TestStaticInitBlock!
封装encapsulation，记忆capsul，胶囊
比如把属性设为私有，同时提供共有的方法访问或者设置属性值
继承与组合
继承：isa
package cn.bjsxt.oop.inherit;
/**
* 测试继承
* @author dell
*
*/
public class Animal /*extends Object*/ {
String eye;
public void run(){
System.out.println("跑跑！");
}
public void eat(){
System.out.println("吃吃！");
}
public void sleep(){
System.out.println("zzzzz");
}
public Animal(){
super();
System.out.println("创建一个动物！");
}
}
class Mammal extends Animal {
public void taisheng(){
System.out.println("我是胎生");
}
}
class Bird extends Animal {
public void run(){
super.run();
System.out.println("我是一个小小小小鸟，飞呀飞不高");
}
public void eggSheng(){
System.out.println("卵生");
}
public Bird(){
super();
System.out.println("建一个鸟对象");
}
}
组合：hasa
package cn.bjsxt.oop.inherit;
/**
* 测试组合
* @author dell
*
*/
public class Animal2 {
String eye;
public void run(){
System.out.println("跑跑！");
}
public void eat(){
System.out.println("吃吃！");
}
public void sleep(){
System.out.println("zzzzz");
}
public Animal2(){
super();
System.out.println("创建一个动物！");
}
public static void main(String[] args) {
Bird2 b = new Bird2();
b.run();
b.animal2.eat();
}
}
class Mammal2 {
Animal2 animal2=new Animal2();
public void taisheng(){
System.out.println("我是胎生");
}
}
class Bird2 {
Animal2 animal2=new Animal2();
public void run(){
animal2.run();
System.out.println("我是一个小小小小鸟，飞呀飞不高");
}
public void eggSheng(){
System.out.println("卵生");
}
public Bird2(){
super();
System.out.println("建一个鸟对象");
}
}
继承时带来的强制类型转换，和基本数据类型一样，引用数据类型也会有类型的转化
package cn.bjsxt.oop.polymorphism;
public class Animal {
String str;
public void voice(){
System.out.println("普通动物叫声！");
}
}
class Cat extends Animal {
public void voice(){
System.out.println("喵喵喵");
}
public void catchMouse(){
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void voice(){
System.out.println("汪汪汪");
}
public void seeDoor(){
System.out.println("看门！");
}
}
class Tiger extends Animal {
public void voice(){
System.out.println("哇哇哇");
}
}
class Pig extends Animal {
public void voice(){
System.out.println("哼哼哼");
}
}
动物都会发声，重写voice方法，不同的动物有不同的发声方法。有的动物还有自己父类所不具备的方法，猫会抓老鼠，狗会看门。
package cn.itcast_04;
public class Test {
public static void testAnimalVoice(Animal c){
c.voice();
if(c instanceof Cat){
((Cat) c).catchMouse();
}
}
public static void testAnimalVoice(Dog c){
c.voice();
}
public static void testAnimalVoice(Pig c){
c.voice();
}
public static void main(String[] args) {
//父类的引用指向子类的对象
Animal a = new Cat();
//强制类型转化，低到高
Cat a2 = (Cat)a;
//a是Cat实例的引用，会调用捉老鼠的方法
testAnimalVoice(a);
/ /完成了强制类型转化
a2.catchMouse();
Animal b = new Dog();
Animal c = new Tiger();
testAnimalVoice(b);
testAnimalVoice(c);
}
}
要考虑编译（eclipse不带有红叉报错）和运行阶段的错误（不抛出异常，比如ClassCastException）
代码改成：
Animal a = new Animal();
//强制类型转化，低到高
Cat a2 = (Cat)a;
则：抛出
cn.itcast_04.Animal cannot be cast to cn.itcast_04.Cat。
父类不可以强制转换为子类，因为子类有的方法父类可能没有
相关推荐
封装继承多态总结
在这个实例中，我们将探讨四个关键概念：封装、继承、多态以及文件流操作，这些都是Java中的核心特性，也是理解OOP（面向对象编程）的基础。 首先，**封装**是面向对象编程的核心理念之一，它涉及将数据和方法捆绑...
Educoder题目：Java面向对象 - 封装、继承和多态答案解析
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析
java封装 继承与多态 程序设计 类与对象
java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素...
本资源摘要信息将对 Java 基础知识点进行总结，涵盖继承、封装、多态等概念，并对面向对象的设计、数据库设计模式等进行讲解。 继承 继承是 Java 中的一种机制，允许一个类继承另一个类的属性和方法。继承的语法是...
java面向对象的基本知识,封装继承多态等
JAVA 封装继承与多态 PPT 教案学习 JAVA 封装继承与多态是面向对象程序设计语言中三个重要的概念，本文将对这三个概念进行详细的解释。 一、封装 封装是指隐藏对象的内部细节，使对象外部不能随意存取对象的内部...
OOP 的主要特征包括封装、继承和多态。 1. **封装**：封装是将数据和操作数据的方法捆绑在一起，隐藏对象的属性和实现细节，仅对外提供公共访问方式。这样可以减少外部环境对对象的影响和破坏，提高代码的安全性和...
Java 封装继承多态详解 Java 中的封装、继承和多态是面向对象编程（Object Oriented Programming）三大特性。下面，我们将详细介绍这三者之间的关系和应用。 封装是指将数据和方法放入类中，并控制对数据的访问...
在Java中，`extends`关键字用于实现继承，多态则通过方法重写和抽象类/接口来实现。 3. **类和对象**：类是对象的蓝图，它定义了对象的属性（变量）和行为（方法）。对象是类的实例，具有类定义的属性和方法。Java...
Java 中继承与多态的题目 本资源摘要信息是关于 Java 中继承和多态的题目，涵盖了面向对象编程的基本概念和继承机制的应用。 继承的概念 继承是面向对象编程的一种机制，允许一个类（子类）继承另一个类（父类）...
面向对象的概念 掌握类的继承、方法重写、super关键字的使用、final关键字 熟悉面向对象继承和多态的概念
java总结，基础语法，面向对象，封装继承多态，异常
这个名为“前端模块化脚手架”的工具，旨在为前端开发者提供一个类似于Java语言的封装、继承和多态特性的开发环境。通过这样的框架，开发者可以在JavaScript中模拟出面向对象编程的特性，使前端开发更加规范和高效。...
通过分析给定的文件名称"demo"，我们可以推测这是一个示例代码或者演示程序，可能包含了对Java封装、继承和多态的实践应用。在深入研究这个"demo"文件之前，开发者可以先理解这三个基本概念，以便更好地理解代码逻辑...
封装、继承、多态 一、 封装 封装是面向对象编程的三大特性之一，它是指将同一类事物的特性与功能包装在一起，对外暴露调用的接口...Java 面向对象的三大特性是：封装、继承与多态。这三大特性是面向对象编程的核心。
封装、继承和多态是面向对象编程的三大特性，它们是Java、C#、Python等许多编程语言中的核心概念。本文将通过一个实例详细解析这三个概念，并以`ConsoleApplication1`为例来阐述。 首先，封装是面向对象编程的基础...
在Java编程语言中，继承、封装和多态是面向对象编程的三大核心概念，它们构成了Java类层次结构的基础。在这个名为"four_java继承封装和多态_four_againgpg_"的压缩包中，我们预计将看到三个不同的Java类，这些类展示...