继承extends、super、this、方法重写overiding、final、代码块_DAY08
1:Math类的随机数(掌握)
类名调用静态方法。
包:java.lang
类:Math
方法:public static double random():
Java.lang包下的类是不用导包就可以直接使用的。
产生1-100之间的随机数:
int number = (int)(Math.random()*100)+1;
2:如何使用API。(掌握)
A:找到文档,打开文档。
B:点击左上角的显示变成隐藏,然后点击索引
C:你应该知道你要找谁?Math
所以,你就在那个输入框里面输入Math,然后回车,再回车。
D:看这个类的结构
java.lang
类 Math
java.util
类 Scanner
如果是java.lang包下的类,是可以直接使用的。(Math),否则,就需要导包才能使用。(Scanner)
E:看看对这个类的说明。
F:看构造方法
名称:字段 -- 成员变量 -- 属性。
a:有构造方法,那么,就通过构造方法创建对象使用。
b:没有构造方法,那么,这个类的成员一般都是静态。
通过类名调用。
G:按照正常的操作使用方法。
左边:
是否静态:如果静态修饰,那么可以通过类名调用。否则,就必须创建对象调用。
是否有明确返回值:如果是void类型,就直接调用即可。否则,就可以输出或者赋值。
右边:
看方法名:不要写错了。
看参数:看参数类型及个数。
3:继承(掌握)extends
(1)把多个类中的相同的属性和行为进行抽取,封装到一个类中,然后再建立新类的时候,不需要从头做起,继承刚才定义的那个类即可。
(2)好处:
A:提高代码的复用性。
B:让类与类之间产生了一个关系,是多态的前提。
(3)什么时候使用继承?
A:如果类之间存在着:is a 的关系,就可以考虑使用继承。
B:不要为了继承部分功能,而去使用继承。详细见例子:
/* 继承一定要符合is a 的关系。 */ class Demo5 { public static void main(String[] args) { System.out.println("Hello World!"); } } class Animal { String name = "巴马"; int age = 80; public void eat(){ System.out.println("吃"); } public void sleep(){ System.out.println("睡"); } private void method(){} } class Cat extends Animal { public void climb(){ System.out.println("爬树"); } public void catchM(){ System.out.println("抓耗子"); } public void eatM(){ System.out.println("生吃耗子"); } } class Person extends Cat{} //不要为了人有“爬树”和“抓耗子”的工能,而去继承Cat类,语法上没有错误,但是在逻辑上有问题。因为Cat类还有“生吃耗子”工能,而人没有。
(4)继承的特点:
A:Java只支持单继承,不支持多继承。
为什么?如果支持多继承,就会有调用不明确的问题。
B:Java支持多层(重)继承。
例子:
/* 继承的特点: 支持单继承,不支持多继承。 支持多层继承。 Object是多有类的直接或间接父类。 */ class Demo4 { public static void main(String[] args) { Person p = new Person(); System.out.println(p.name); System.out.println(p.age); p.eat(); p.sleep(); } } class Animal { String name = "巴马"; int age = 80; public void eat(){ System.out.println("吃"); } public void sleep(){ System.out.println("睡"); } private void method(){} } class Pig extends Animal{} //class Person extends Monkey,Animal{} //一个类不能多继承 class Monkey extends Animal{} class Person extends Monkey{} //支持多层继承
(5)super和this的区别?
A:super是一个关键字,代表父类的存储空间标识。(可以理解为父亲对象的引用,单实际不是父亲对象的引用)
B:它和this的用法相似
a:成员变量
this.变量 -- 本类的
super.变量 -- 父类的
b:构造方法
this(...) -- 本类的
super(...) -- 父类的
c:成员方法
this.方法名() -- 本类的
super.方法名() -- 父类的
例子:
/* super:代表父类的内存空间 使用方式: 1、super区分父类成员变量与子类成员变量 2、super放在构造方法中第一行,用来调用父类的构造方法 */ class Demo6 { public static void main(String[] args) { //Person p = new Person(); //p.showMe(); Person p2 = new Person("巴豆",3); p2.showMe(); } } class Animal { String name = "巴马"; int age = 80; //定义空参构造 /* public Animal(){ System.out.println("我是父类的空参构造方法"); } */ //定义两个参数构造 public Animal(String name,int age) { System.out.println("我是父类的有参构造方法"); this.name = name; this.age = age; } public void eat(){ System.out.println("吃"); } public void sleep(){ System.out.println("睡"); } private void method(){} } class Person extends Animal { String name = "巴驴"; int age = 60; public Person(){ //super(); //默认都有super()构造方法 super("aaa",100); System.out.println("我是子类的空参构造方法"); } public Person(String name,int age) { //this(); //this不可以与super同时调用构造方法 super(name,age); System.out.println("我是子类的有参构造方法"); this.name = name; this.age = age; } public void showMe(){ String name = "巴骡"; int age = 70; //局部变量直接写变量名即可 System.out.println("姓名:"+name+" 年龄:"+age); //本类的成员变量加this区分 System.out.println("姓名:"+this.name+" 年龄:"+this.age); //父类的成员变量加super区分 System.out.println("姓名:"+super.name+" 年龄:"+super.age); //如果同时存在,则就近原则 } }
(6)继承关系内存图:
(7)子父类实例化过程
子类中所有的构造函数默认都会访问父类中空参数的构造函数,原因是构造方法中第一行默认的super(),子类具备父类中的数据,所以需要先明确父类是如何初始化的,即调用父类的构造方法。父类存储空间优于子类对象。
大致顺序:
(8)标准的继承关系代码
/* 标准的继承关系代码 */ class Demo9 { public static void main(String[] args) { Cat cat = new Cat("Tom",5,"黄黑条"); cat.method(); cat.method2(); cat.setName("kitty"); cat.setColor("pink"); cat.showMe(); } } class Animal { private String name; private int age; public Animal() {} public Animal(String name,int age) { this.name = name; this.age = age; } public void method(){ System.out.println("我是父类的第一个方法"); } public void method2(){ System.out.println("我是父类的第二个方法"); } //----------------------------------------------------------------- public void setName(String name) { this.name = name; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; } } class Cat extends Animal { private String color; public Cat() {} public Cat(String name,int age,String color) { super(name,age); this.color = color; } public void method(){ System.out.println("我是子类的重写的第一个方法"); } public void showMe(){ System.out.println("name:"+super.getName()+" age:"+getAge()+" color:"+color); } public void setColor(String color) { this.color = color; } public String getColor() { return color; } }
(9)子父类中成员变量的用法:
A:名称不同,这个太简单了。
B:名称相同,子类对象的在使用的时候:
先找子类局部范围
再找子类成员范围
最后找父类成员范围
父类的父类成员范围
(10)子父类中成员方法的用法:
A:名称不同,这个太简单了。
B:名称相同,子类对象的在使用的时候:
先找子类的
再找父类的
C:方法重写(overiding)
要求:
a.子类方法访问权限需要大于等于父类方法访问权限
b.返回值类型:
基本类型/void:必须相同
引用类型:子类返回值类型必须为父类返回值类型的子类
c.函数名相同
d.参数列表:相同为重写,不同时为重载
应用:子类需要父类功能,但又在功能上又有多增加时,可以复写父类方法。子类比父类更强大。
注意事项:
a.父类中私有方法不可以被覆盖。
b.在子类中想调用父类自己的方法可以使用super关键字
c.静态只能覆盖静态。(这个不能算,因为静态跟类相关)
例子:
class OveridingMethod { public static void main(String[] args) { Zi2 zi2 = new Zi2(); zi2.method2(); } } class Fu { public void method() { } } class Zi extends Fu { public void method() { } } class Fu2 { Fu fu = new Fu(); public Zi method2() { ////报错,子类返回值类型必须为父类返回值类型的子类,此处不是。 System.out.println("我是子类2的方法"); return zi; } } class Zi2 extends Fu2 { Zi zi = new Zi(); public Fu method2() { //报错,子类返回值类型必须为父类返回值类型的子类,此处不是。 System.out.println("我是子类2的方法"); return fu; } }
(11)子父类中构造方法的用法:
A:子类的初始化过程中,首先回去执行父类的初始化动作。
因为子类的构造方法中默认有一个super()。
为什么?子类要使用父类的成员变量,这个初始化,必须在子类初始化之前完成。
所以,子类的初始化过程中,会先执行父类的初始化。
B:如果父类没有无参构造方法
A:使用super调用父类的带参构造。推荐方式。
B:使用this调用本身的其他构造。
4:代码块(面试题)
(1)代码块:写代码的区域,使用{}作为范围限定
局部代码块:
位置:方法内
作用:控制变量作用域
构造代码块:
位置:成员位置,类中,方法外
作用:将构造器中相同代码抽取,在构造器前执行
静态构造代码块:
位置:成员位置,类中,方法外
作用:只在第一次创建对象时初始化一次
/*
代码块:写代码的区域,使用{}作为范围限定 局部代码块:
位置:方法内
作用:控制变量作用域
构造代码块:
位置:成员位置,类中,方法外
作用:将构造器中相同代码抽取,在构造器前执行
静态构造代码块:
位置:成员位置,类中,方法外
作用:只在第一次创建对象时初始化一次 默认初始化>显示初始化>构造代码块>构造方法
*/
class Demo2
{
public static void main(String[] args)
{
int i = 10;
{
int i2 = 20;
}
System.out.println(i);
//System.out.println(i2); 超出作用域 Person p = new Person();
Person p2 = new Person("巴马",80);
p2.showMe(); }
} class Person
{
//定义Person类的属性
private String name = "巴骡";
private int age = 60; //定义一个构造代码块
{
System.out.println("我是一个构造代码块");
name = "巴驴";
age = 70;
System.out.println("我是要初始化的步骤1");
System.out.println("我是要初始化的步骤2");
System.out.println("我是要初始化的步骤3");
System.out.println("我是要初始化的步骤4");
} static{
System.out.println("我是一个静态构造代码块");
} //定义Person类的构造方法
public Person(){
System.out.println("我是空参构造方法");
}
public Person(String name,int age){
System.out.println("我是有参构造方法");
//this.name = name;
//this.age = age;
} public void showMe(){
System.out.println("name:"+name+" age:"+age);
} //定义Person类的普通方法
public void eat(){
System.out.println("吃了");
} public void sleep(){
System.out.println("睡了");
}
//定义Person类的getters和setters
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
} public void setAge(int age) {
this.age = age;
} public int getAge(){
return age;
}
}
(2)执行顺序:
静态代码块 --> 构造代码块 --> 构造方法
默认初始化>显式初始化>构造代码块初始化>构造方法初始化
(3)注意事项:
静态代码块只执行一次
5:final(掌握)(简单总结为:修饰的东西不能变!)
(1)是一个关键字,可以用于修饰类,成员变量,成员方法。
(2)特点:
它修饰的类不能被继承。
它修饰的成员方法是不能被子类重写的。
它修饰的成员变量是一个常量。常量必须有值,且常量的值只能赋值一次。如果是成员变量,只需要在对象创建之前赋值即可。
引用类型常量可以更改其堆内存对象中的值。
例:
a.final修饰的类不能被继承。
class Demo10 { public static void main(String[] args) { } } final class Fu{ // 修饰类,类不可以被继承。 } class Zi extends Fu{ }
b.它修饰的成员方法是不能被子类重写的.
class Demo10 { public static void main(String[] args) { } } class Fu{ final public void showMe(){} //修饰方法,方法不可以被重写。 } class Zi extends Fu{ public void showMe(){} }
c.常量必须有值
class Demo10 { public static void main(String[] args) { final int a; System.out.println(a); //常量必须有值。此处会报错 } }
d.常量的值只能赋值一次
class Demo10 { public static void main(String[] args) { final int a=10; a=20; //常量的值只能赋值一次,此处报错 System.out.println(a); } }
e.如果是成员变量,只需要在对象创建之前赋值即可
class Demo10 { public static void main(String[] args) { Fu fu = new Fu("唐嫣"); //创建对象时赋值 } } class Fu { //成员变量 final private String name; final private int age = 20; //创建成员变量时赋值 //构造器 public Fu(String name) { this.name = name; } }
f.引用类型常量可以更改其堆内存对象中的值,引用类型变量被final修饰,不能再指向其他对象地址
6:同一个文档里不能有两个以上Public修饰的类
public class name{}
public class age{} //同一个文档里有两个以上Public修饰的类会报错。
附:
题一:面向对象基础知识全涵盖例(标准学生类的定义及使用)
/* 标准学生类的定义及使用 */ class Test { public static void main(String[] args) { /* 创建对象 使用对象调用方法 使用对象调用方法访问属性 */ Student s = new Student(); s.setName("近平"); s.setAge(24); s.address = "上海,广州也可以!"; s.study("java"); System.out.println(s.eat()); System.out.println(s.hitBeanBean(3)); Student.jiayou("i have a dream,a code dream and a money dream!"); Student s2 = new Student("克强",26); s2.study("SQL"); System.out.println(s2.eat()); System.out.println(s2.hitBeanBean(6)); Student.jiayou("i have a dream,a code dream and a money dream!"); } } /* 给类命名 成员变量的定义 构造方法的定义 普通方法的定义 getters/setters */ //给类命名 class Student { //成员变量的定义 private String name; private int age; public static String address = "北京,梦开始的地方!"; //构造方法的定义 public Student(){} //一个参数的构造也可以定义 public Student(String name,int age) { this.name = name; this.age = age; } //普通方法的定义 public void study(String neirong) { System.out.println("我学的是"+neirong); } public String eat(){ return "我已经吃了!"; } public String hitBeanBean(int cishu) { return "我今天打了"+cishu+"次豆豆。我很舒服。"; } public static void jiayou(String xuanyan) { System.out.println(xuanyan); } //getters/setters public void setName(String name) { this.name = name; } public String getName(){ return name; } public void setAge(int age) { this.age = age; } public int getAge(){ return age; } }
继承extends、super、this、方法重写overiding、final、代码块_DAY08的更多相关文章
- 包、继承、Super、方法重写
1 包_继承 1.1 包 包(package) 用于管理程序中的类,主要用于解决类的同名问题.包可以看出目录. 包的作用 [1] 防止命名冲突. [2] 允许类组成一个单元(模块),便于管理和维护 [ ...
- 关于继承的基本知识,方法重写,final和abstract的使用, 动态绑定和静态绑定的知识
一.继承: 涉及关键字: extends(继承) super final abstract 特点: 1.类与类之间可以用 XX是XX来描述 , 那么他们之间就存在继承关系. 2.Java中不支持多继 ...
- 2.2.9静态同步synchronized方法与synchronized(class)代码块
关键字synchronized还可以应用在static静态方法上,这样写那是对当前的*.java文件对应的class类进行持锁, 测试如下 package com.cky.bean; /** * Cr ...
- Java——final代码块是否一定被执行---18.11.08
辨析:final语句块一定会被执行吗? 答案是 不一定!!! 至少有两种情况下finally语句是不会被执行的: (1)try语句没有被执行到,如在try语句之前return就返回了,这样final语 ...
- Java继承:super关键字、构造器、final用法
一.继承 继承好处 1.提高代码的重用性 2.提高代码的扩展性和维护性 3.为多态打下了基础 继承类型 继承子类创建对象的过程 二.super关键字的使用 理解:super代表父类的引用,用于访问父类 ...
- es6 Class的继承extends & super
Class之间可以通过extends关键字,实现继承. 子类会继承父类的属性和方法. class Point { constructor(x, y) { this.x = x; this.y = y; ...
- 堆、栈、方法区、静态代码块---Java
java 堆.栈.方法区 堆区: 1.存储的全部是对象,每个对象都包含一个与之对应的class的信息.(class的目的是得到操作指令) 2.jvm只有一个堆区(heap)被所有线程共享,堆中不存放基 ...
- static方法,属性,代码块初始化顺序和执行顺序
http://greateryang.blog.163.com/blog/static/81953375201232621031508/
- Java面向对象----继承概念,super关键字
继承概念: 继承需要符合的关系 is-a , 父类通用更抽象,子类更特殊更具体 类之间的关系 继承体现 组合体现 实现接口体现 继承的意义 代码重用 体现不同抽象层次 extends关键字 Sup ...
随机推荐
- Transforming Real-Time Task Graphs to Improve Schedulability
Basic idea: insert artificial delays to the release times of certain vertices of a task graph to ge ...
- winSockets编程(四)阻塞模式(服务端)
在阻塞模式下,在I/O操作完成前,执行的操作函数将一直等候而不会立即返回,该函数所在的线程会阻塞在这里.相反,在非阻塞模式下,套接字函数立即返回,而不管I/O是否完成. 重点知识和思想: ////// ...
- 学习node.js的C++扩展
本想买本书,可是太贵,了一下作者可惜没有回应,不然也会去支持一下.于是自己baidu罗.先是从这个入手 安装好环境 https://github.com/nodejs/node-gyp#install ...
- MIT Molecular Biology 笔记2 DNA的突变和修复
视频 https://www.bilibili.com/video/av7973580?from=search&seid=16993146754254492690 教材 Molecular ...
- MIT Molecular Biology 笔记1 DNA的复制,染色体组装
视频 https://www.bilibili.com/video/av7973580?from=search&seid=16993146754254492690 教材 Molecular ...
- Shell编程-08-Shell中的循环语句
目录 while语句 until语句 for语句 select语句 循环中断控制 循环语句总结 循环语句常用于重复执行一条命令或一组命令等,直到达到结束条件后,则终止执行.在Shell中常见的 ...
- js跳转页面方法实现汇总
一.页面之间的跳转传参 1.在页面之间跳转的方式有两种: window.location.href=”test.html?num=10” 地址会改变参数也会被传递但是不会打开新窗口 window. ...
- hihocode 1336 Matrix Sum 【二维树状数组】
题目 两个操作: 1. Add x y value: Add value to the element Axy. (Subscripts starts from 0 2. Sum x1 y1 x2 y ...
- StringBuffer 去掉最后一个字符
StringBuffer stringBuffer=new StringBuffer (); stringBuffer.append("aaa,"); stringBuffer.d ...
- cvpr2015总结
cvpr所有文章 http://cs.stanford.edu/people/karpathy/cvpr2015papers/ CNN Hypercolumns for Object Segmenta ...