Java基础_基础语法知识8

面向对象

1.final关键字
(1).final关键字意思是最终的，最后的。

(2).final关键字可以修饰类，方法以及变量。

(3).final关键字修饰类，这一个类就编程最终类，这一个时候最终类不可以被继承。
final关键字修饰方法，该方法不能够被重写，以及覆盖。
final关键字修饰变量，这一个时候该变量就是一个常量，也就是不可以改变值。

(4).final关键字在继承中的使用测试:
//父类
public class Father {
public int num = 10;
public final int num1 = 20;
}
//子类以及测试
public class Son extends Father{

public void sonTest(){
num = 20;
System.out.println("子类访问的变量是:"+num);
//num1 = 30; 报错，这里面的num1访问的其实是flather父类中的 变量num1，无法未常量赋值，报错
//System.out.println("子类访问的变量是:"+num1);
}

public static void main(String[] args) {
Son s = new Son();
s.sonTest();
}
}

(5).final关键字的相关测试:
修饰的是基本类型，基本类型的值不可以改变
修饰的是引用类型，引用类型的地址值不可以改变。但是该对象的堆内存值是可以改变的。

//代码测试
public class Student {
int age = 10;

public static void main(String[] args) {
int x = 10;
x = 100;
System.out.println(x);

final int y = 20;
System.out.println(y);
System.out.println("-------------------");

//局部变量是引用类型
Student st = new Student();
System.out.println(st.age);
st.age = 200;
System.out.println(st.age);
System.out.println("--------------------");

//final关键字修饰引用类型，实质保证的是引用类型的地址值不改变，修饰一般类型，那么就是值不改变
final Student sdt = new Student();
System.out.println(sdt.age);
sdt.age = 300;
System.out.println(sdt.age);
System.out.println("---------------------");

//报错，无法给最终变量分配值
//sdt =new Student();
}
}

(6).final修饰的变量的初始化时机
A:被final修饰的变量只能够赋值一次；
B:final修饰的变量的初始化时机是在构造方法之前完毕。(非静态的常量)

2.面向对象多态的前提和条件

(1).多态的概述
什么是多态？多态就是某一个事务，在不同的时刻表现出来的不同形态。

举例:
狗的多态表现:
狗可以是狗的类型。也就是 dog dog = new dog();
狗也是动物的类型,狗也是属于一种动物。也就是 动物 dog = new dog();

水的三态变化
水是属于水类型。 water wt = new water();
水汽也是属于水的类型，其实质也是水。水汽 wt = new water();
冰也是属于水的类型，其实质也是水。 冰 wt = new water();

(2).多态的前提
A:俩个类必须有继承的关系。
B:有方法的重写。
没有方法的重写，那么这俩个类之间的关系就没有意义。
C:有父类的引用指向子类。
父类 f = new 子类;

(3).一个多态的基本例子(多态中的成员访问特点)
A:成员变量
编译看左边,运行看左边。
B:构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
C:成员方法
编译看左边,运行看右边。
D:静态方法
编译看左边,运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边)

由于成员方法存在着方法重写，所以它运行看右边。

(4).代码实现:
//父类
public class Father {
public int num = 100;
public void show(){
System.out.println("show fu");
}
public static void function(){
System.out.println("function father");
}
}

//子类以及测试
public class Son extends Father{

public int num = 200;
public int num2 = 1000;

public void show(){
System.out.println("show zi");
}

public void method(){
System.out.println("method zi");
}

public static void function(){
System.out.println("function son");
}

public static void main(String[] args) {
Father f = new Son();
//编译看左边,运行看左边。输出结果:100
System.out.println(f.num);
//找不到符号
//System.out.println(f.num2);
//show zi
f.show();
//报错，找不到方法
//f.method();
f.function();
}
}

//运行结果:
100
show zi
function father

(5).多态的好处
A:提高了代码的维护性(由继承保证)
B:提高了代码的扩展性(由多态保证)

代码实现:[*****]

Animal.java

public class Animal {
public void eat(){
//System.out.println("eat");
}
public void sleep(){
//System.out.println("sleep");
}
}

//扩展类1
Dog.java
public class Dog extends Animal{

public void eat(){
System.out.println("狗吃肉");
System.out.println("狗具体吃什么肉还可以在这里面添加");
}

public void sleep(){
System.out.println("狗趴着睡觉");
System.out.println("狗如何睡觉方法还可以在这里面添加");
}
}

//扩展类2
public class Cat extends Animal{

public void eat(){
System.out.println("猫吃鱼");
}

public void sleep(){
System.out.println("猫躺着睡觉");
}
}

//操作的工具类
//针对动物进行操作的工具类
public class AnimalTools {

//私有化构造
private AnimalTools(){}

public static void UseAnimal(Animal a){
a.eat();
a.sleep();

}
}

//测试类
public class TestDemo {
public static void main(String[] args) {
Cat c = new Cat();
Cat c2 = new Cat();
AnimalTools.UseAnimal(c);
AnimalTools.UseAnimal(c2);
System.out.println("---------");
Dog d = new Dog();
Dog d1 = new Dog();
AnimalTools.UseAnimal(d);
AnimalTools.UseAnimal(d1);

}
}

//由上面的代码可以看出，多态其实就是一个树形结构的数据结构，从根(父类)到每一个具体的叶子(子类或者是实现类)，我们
可以通过访问根的方式去访问每一个叶子节点。

(6).多态的弊端
只能够使用父类中定义过的方法，不能够使用子类的特有方法，也就是说子类如果要定义一个自己特有的方法，那么这个就必须
在父类中也有相同的方法声明。

3.多态中的转型问题[*****]

(1).为什么会出现多态中的转型？
多态中的转型问题主要是为了解决多态的弊端。为了能够让子类自己也能够使用子类的特有功能这一个时候就需要把父类和
子类之间进行一个按照需求的转化。

(2).向上转型
Fu f = new Zi();
向下转型
Zi z = (Zi) f; //但是要求f必须是能够转化为子的

4.面向对象多态案例
//父类
public class Animal {
public void eat(){
//System.out.println("eat");
}
public void sleep(){
//System.out.println("sleep");
}

}

//俩个子类
//狗类
public class Dog extends Animal{

public void eat(){
System.out.println("狗吃肉");
System.out.println("狗具体吃什么肉还可以在这里面添加");
}

public void sleep(){
System.out.println("狗趴着睡觉");
System.out.println("狗如何睡觉方法还可以在这里面添加");
}

//狗自己特有的方法
public void lookHome(){
System.out.println("小狗可以看家");
}
}

//猫类
public class Cat extends Animal{

public void eat(){
System.out.println("猫吃鱼");
}

public void sleep(){
System.out.println("猫躺着睡觉");
}

//猫自己特有的
public void catchMouse(){
System.out.println("小猫可以抓老鼠");
}
}

//父类的工具类
//针对动物进行操作的工具类
public class AnimalTools {

//私有化构造
private AnimalTools(){}

public static void UseAnimal(Animal a){
a.eat();
a.sleep();

}
}

//测试类
public class TestDemo {
public static void main(String[] args) {
Animal cat = new Cat();
//通用方法调用
AnimalTools.UseAnimal(cat);
//向下转型
Cat cat2 = (Cat)cat;
cat2.catchMouse();
System.out.println("------------------");
Animal dog = new Dog();
AnimalTools.UseAnimal(dog);
Dog dog2 = (Dog) dog;
dog2.lookHome();
}
}

原文地址：https://www.cnblogs.com/nwxayyf/p/10133699.html

时间： 2024-10-11 14:31:20

Java基础_基础语法知识8的相关文章

Java基础_基础语法知识2

1.运算符 (1).什么是运算符 运算符是指对常量和变量进行操作的符号.用于操作我们定义的变量和常量进行处理. (2).运算符的分类 A:算数运算符 B:赋值运算符 C:比较运算符 D:逻辑运算符 E: 位运算符 F:三目运算符 (3).算术运算符 A:'+' a=3,b=4,a+b=7 表示对变量或者常量进行数据的加法运算 B:'-' a=3,b=4,b-a=1 表示对变量或者常量进行数据的减法运算 a=-1 表示该常量数据是一个负数 C:'*' a=3,b=4,a*b=12 表示对变量或者常

Java基础_基础语法知识5

1.二维数组 (1).什么是二维数组 二维数组其实就是一个元素为一维数组的数组. (2).二维数组定义格式 A:二维数组的定义格式 数据类型[][] 数组名称 = new 数据类型[m][n]; m表示这一个二维数组有多少个一维数组.(第一个位置数据) n表示每一个一维数组有多少个元素.(第二个位置数据) 使用举例: int[][] arr = new int[3][2]; //说明: 上述代码定义了一个int类型的二维数组. m=3;表示这一个二维数组有3个一维数组,也就是arr[0],arr

Java基础_基础语法知识7

面向对象 1.使用java提供的帮助文档 使用java提供的jdk帮助文档.(演示) (1).如何使用帮助文档 A:打开帮助文档 B: 点击显示,找到索引,找到输入框. C: 知道你要找哪一个?如Scanner()键盘输入,如Math() D: 看是在哪一个包下面 如果说是在java.lang包下面的类不需要导入(如:math()),别的包都需要导入. 如:Scanner-->import java.util.Scanner; E: 再简单的看类的解释和说明,注意看这一个类的版本. F: 在看类

Java基础_基础语法知识10

1.形式参数 参数类型 基本类型,如:int float double 引用类型: 类:这一个时候参数需要的是一个该类的对象. 抽象类:需要的是该抽象的类的子类对象. 接口:需要的是该接口的实现类对象. 2.返回值类型 基本类型:就是一般的基本类型(省略) 引用类型: 类:需要返回的是该类对象. 抽象类:返回的是该抽象类的子类对象. 接口:返回的是该接口的实现类的对象. 3.链式编程 所谓的链式编程实质就是对象调用方法,然后反复的调用该对象的方法,所以链式编程每次调用返回的是一个对象. new

2.java学习_基础知识（标识符、常量、变量、运算符）

标识符 定义 在程序中我们自定义的一些名称在编程的过程中,经常需要在程序中定义一些符号来标记一些名称,如包名.类名.方法名.参数名.变量名,这些符号被称为标识符. 组成元素 英文大小写字母 数字0~9 下划线_和美元符号$ 规则 不可以以数字打头,如:4student ,×不可以使用java的关键字,如class不能使用严格区分大小写,如Xxx和xxx,是两个变量 原则 见名知意,驼峰命名 规范 掌握包名多个单词组成时,所有单词都小写.举例:xxxyyyzzz类名和接口名多个单词组成时,所有单词

java变量_基础篇

1.变量的命名: 变量命名的一般规则: 1.字母.数字."$"或"_"符组成 2.不能以纯数字开头 3.严格区分大小写 4.不能使用Java保留字 1 //java基础八大类型 2 //int类型,只能输入整数 3 int x1=10; 4 //short类型,只能输入整数 5 short x2=10; 6 //byte和short的取值范围比较小,而long的取值范围太大, 7 //占用的空间多,基本上int可以满足我们的日常的计算了, 8 byte x3 = 1

JS基础_基本语法

1 <!DOCTYPE html> 2 <html> 3 <head> 4 <meta charset="UTF-8"> 5 <title></title> 6 <script type="text/javascript"> 7 8 /* 9 多行注释 10 JS注释 11 多行注释,注释中的内容不会被执行,但是可以在源代码中查看 12 要养成良好的编写注释的习惯,也可以通过注释来对

XXLii_7.21笔记 Linux基础_基础命令

1.用户 Linux总共分两大类用户:管理员用户和普通用户 管理员:UID : 0 超级用户,权限大到无人能敌,能自杀. 普通用户:UID:(1~65535) 权限有限,用于平常维护使用 系统用户:UID(Centos6版本为1~499,Centos7版本为1~999) 普通用户:UID(Centos6版本为500~60000,Centos7版本为1000~60000) 2.终端 终端分为: 虚拟终端(TTY):附加在物理终端之上的以软件方式虚拟实现的终端,配置文件              

Java语言的基础知识

第三章 1.在java源文件编辑器中,选择某个成员变量,然后按住shift+alt+j,Eclipse会自动添加JavaDoc文档注释结构,如果选择的是方法,还会自动添加参数名称. 2.Java语言规定标示符是由任意的字母.下划线.美元符号和数字组成,并且第一个字符不能使数字,标示符不能使java中的保留关键字. 3.在Java语言中允许使用汉字或其他语言文字作为变量名,如int 年龄 =21;在程序运行时不会报错,但建议尽量不要使用这些语言作为变量. 4.java用关键字final来声明常量,