继承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 ...
随机推荐
- 引用限定符(c++11)
1.概念 1)下面这种情况将对一个右值调用成员函数.对右值赋值 string s1 = "abc", s2 = "def"; auto n = (s1 + s2 ...
- CodeForces 916C Jamie and Interesting Graph (构造)
题意:给定两个数,表示一个图的点数和边数,让你构造出一个图满足 1- n 的最短路是素数,并且最小生成树也是素数. 析:首先 1 - n 的最短路,非常好解决,直接 1 连 n 就好了,但是素数尽量 ...
- 16-margin的用法
margin塌陷问题 当时说到了盒模型,盒模型包含着margin,为什么要在这里说margin呢?因为元素和元素在垂直方向上margin里面有坑. 我们来看一个例子: html结构: <div ...
- C#——字符串
aaarticlea/jpeg;base64,iVBORw0KGgoAAAANSUhEUgAAANwAAAA8CAMAAAA6wCQxAAAAGFBMVEX////w9f5kb9TGyu3b6P6hp
- Cmd Markdown语法参考
https://www.zybuluo.com/mdeditor markdown语法说明 Markdown中公式的写法 $$P(X=k)=C_n^kp^k(1-p)^{n-k}$$ 欢迎使用 Cmd ...
- Write Markdown Syntax Online Document with Sphinx and Pandoc
There is no doubt that we have to write doc while we are developing software. But How do you write d ...
- c需要注意的细节
1.在纯的.c文件中,例如struct Stu,之后不可以只使用Stu作为关键字来表示这个定义的结构体类型,一定要使用struct Stu一起作为类似int这种关键字来定义或者获取size. 2.函数 ...
- 第十四个目标 (fzu)
http://acm.fzu.edu.cn/contest/problem.php?cid=151&sortid=8 Problem Description 目暮警官.妃英里.阿笠博士等人接连 ...
- 省赛在即！最大流问题回顾学习！！DInic
Dinic是很好的算法,但是我还是从ek算法复习起步 面对最大流问题,印象最深的就是反向边的思想,他给我们提供了反悔的机会,其实现在放到实际上来想,可以相当于两边的水都流了这条边,只是方向不一样,放到 ...
- SRM476
250pt 题意:饲养N<=50只Badgers,每只食量是X[i],当没看到别的一只Badgers吃东西时,它的食量就会增加Y[i],现在一共用P的粮食,问最多能养的起多少只獾. 思路:枚举一 ...