Java 学习 day07
01-面向对象(继承-概述).avi
package myFirstCode;
/*
将学生和工人的共性描述提取出来,单独进行描述,
只要让学生和工人与单独描述的这个类有关系,就可以了。 继承:
1. 提高了代码的复用性
2. 继承让类与类之间产生了关系,有了这个关系,才有了多态的特性。 注意:千万不要为了获取其他类的功能,简化代码而继承。
必须是类与类之间有所属关系才可以继承。所属关系 is a。谁是谁中的一员。
*/ class Person
{
String name;
int age; } class Student extends Person
{
void study()
{
System.out.println("good study");
}
} class Worker extends Person
{
void work()
{
System.out.println("good work");
}
} class ExtendsDemo { public static void main(String[] args) {
// TODO Auto-generated method stub } }
02-面向对象(继承-概述2).avi
package myFirstCode;
/*
将学生和工人的共性描述提取出来,单独进行描述,
只要让学生和工人与单独描述的这个类有关系,就可以了。 继承:
1. 提高了代码的复用性
2. 继承让类与类之间产生了关系,有了这个关系,才有了多态的特性。 注意:千万不要为了获取其他类的功能,简化代码而继承。
必须是类与类之间有所属关系才可以继承。所属关系 is a。谁是谁中的一员。 class C
{
void demo1(){}
} class A extends C
{
// void demo1(){}
void demo2(){}
} class B extends C
{
// void demo1(){}
void demo3(){}
} Java语言中:java只支持单继承,不支持多继承。 因为多继承容易带来安全隐患:当多个父类中定义了相同功能,
但功能内容不同时,子类对象不确定要运行哪一个。
但是Java保留这种机制。并用另一种体现形式类完成表示,叫做多实现。 java支持多层继承。也就是一个继承体系。C继承了B,B又继承A。 如何使用一个继承体系中的功能呢?
想要使用体系,先查阅体系父类的描述,因为父类中定义的是该体系中共性功能。
通过了解共性功能,就可以知道该体系的基本功能。
那么这么体系已经可以基本使用了。
那么在具体调用时,要创建最子类的对象,为什么呢?一是因为有可能父类不能创建对象,二是创建子类对象可以使用更多的功能,包括基本的也包括特有的。 简单一句话:查阅父类功能,创建子类对象使用功能。 */ class Person
{
String name;
int age; } class Student extends Person
{
void study()
{
System.out.println("good study");
}
} class Worker extends Person
{
void work()
{
System.out.println("good work");
}
} class ExtendsDemo { public static void main(String[] args) {
// TODO Auto-generated method stub } }
03-面向对象(聚集关系).avi
聚集:has a,谁里面有谁。
聚合:球员和球队
组合:胳膊和人
04-面向对象(子父类中变量的特点).avi
package myFirstCode; /*
子父类出现后,类成员的特点: 类中成员:
1. 变量
2. 函数
3. 构造函数 1.变量
如果子类中出现非私有的同名成员变量时,
子类要访问本类中的变量,用this;
子类要访问父类中的同名变量,用super; super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。 this - 本类引用
super - 父类引用
*/ class Fu
{
int num = 4; } class Zi extends Fu
{
//int num = 5;
void show()
{
System.out.println(super.num);
}
} public class ExtendsDemo2 { public static void main(String[] args) {
// TODO Auto-generated method stub
Zi z = new Zi();
z.show();
// System.out.println(z.num+"...."+z.num); } }
05-面向对象(子父类中函数的特点-覆盖).avi
package myFirstCode; /*
2. 子父类中的函数 。 当子类出现和父类一模一样的函数时,
当子类对象调用该函数,会运行子类函数的内容。
如同父类的函数被覆盖一样。 这种情况是函数的另一个特性:重写(覆盖) 当子类继承了父类,沿袭了父类的功能,到子类中,
但是子类虽具备该功能,但是功能的内容却和父类不一致,
这时,没有必要定义新功能,而是使用覆盖特性,保留父类的功能定义,并重写功能内容。 覆盖:
1. 子类覆盖父类,必须保证子类权限大于等于父类权限,才可以覆盖,否则编译失败。
2. 静态只能覆盖静态。 记住大家:
重载:只看同名函数的参数列表。
重写:子父类方法要一模一样。
*/
class Fu
{
void show()
{
System.out.println("fu show");
}
void speak()
{
System.out.println("vb");
}
} class Zi extends Fu
{
void show()
{
System.out.println("zi show");
}
void speak()
{
System.out.println("java");
}
} public class ExtendsDemo3 { public static void main(String[] args) { Zi z = new Zi();
z.show(); }
} //复写的特性
class Tel
{
void show()
{
System.out.println("number");
}
} class NewTel extends Tel
{
void show()
{
//System.out.println("number");
super.show();
System.out.println("name");
System.out.println("pic");
}
}
06-面向对象(子父类中构造函数的特点-子类实例化过程).avi
package myFirstCode; /*
3. 子父类中的构造函数。 在对子类对象进行初始化时,父类的构造函数也会运行,
那是因为子类的构造函数默认第一行有一条隐式的语句 super();
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
*/ class Fu4
{
Fu4()
{
System.out.println("fu run");
}
} class Zi4 extends Fu4
{
Zi4()
{
//super(); 默认的
System.out.println("zi run");
}
Zi4(int x)
{
//super(); 默认的
System.out.println("zi..."+x);
}
} public class ExtendsDemo4 { public static void main(String[] args) {
// TODO Auto-generated method stub
Zi4 z = new Zi4();
Zi4 z1 = new Zi4(4);
} }
fu run
zi run
fu run
zi...4
package myFirstCode; /*
3. 子父类中的构造函数。 在对子类对象进行初始化时,父类的构造函数也会运行,
那是因为子类的构造函数默认第一行有一条隐式的语句 super();
super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super(); 为什么子类一定要访问父类中的构造函数?
因为父类中的数据子类可以直接获取。所以子类对象在建立时,需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时,要先访问以下父类中的构造函数。
如果要访问父类中指定的构造函数,可以通过手动定义super语句的方式来指定。 注意:super语句一定定义在构造函数的第一行。 子类的实例化过程。 结论:
子类的所有的构造函数,默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数内的第一行都有一句隐式super(); 当父类中没有空参数的构造函数时,子类必须手动通过super或者this语句形式来指定要访问的构造函数。 当然:子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。
*/ class Fu4 //extends object
{
Fu4()
{
System.out.println("fu run");
}
} class Zi4 extends Fu4
{
Zi4()
{
//super(); 默认的
//super(4);
System.out.println("zi run");
}
Zi4(int x)
{
//super(); 默认的
//super(2);
System.out.println("zi..."+x);
}
} public class ExtendsDemo4 { public static void main(String[] args) {
// TODO Auto-generated method stub
Zi4 z = new Zi4();
Zi4 z1 = new Zi4(4);
} } class Person
{
private String name;
Person(String name)
{
this.name = name;
}
}
07-面向对象(final关键字).avi
package myFirstCode; /*
final:最终。作为一个修饰符,
1. 可以修饰类,函数,变量。
2. 被final修饰的类不可以被继承。为了避免被继承,被子类复写功能。
3. 被final修饰的方法不可以被复写。
4. 被final修饰的变量是一个常量只能赋值一次,既可以修饰成员变量,又可以修饰局部变量。
当在描述事物时,一些数据的出现值是固定的,那么这时为了增强阅读性,都给这些值起个名字,方便于阅读。
而这个值不需要改变,所以加上final修饰。
作为常量:常量的书写规范,所有的字母都大写,如果由多个单词组成。单词间通过_连接。
5. 内部类定义在类中的局部位置上时,只能访问该局部被final修饰的局部变量。
*/ final class Demo
{
final int x = 3;//x终身为3
final double MY_PI = 3.14;
final void show1()
{}
void show2()
{}
} class SubDemo extends Demo
{
void show1(){}
} public class FinalDemo { public static void main(String[] args) {
// TODO Auto-generated method stub } }
08-面向对象(抽象类).avi
package myFirstCode; /*
当多个类中出现相同功能,但是功能主体不同,
这是可以进行向上抽取。这时,只抽取功能定义,而不抽取功能主体。 抽象:看不懂 抽象类的特点:
1. 抽象方法一定定义在抽象类中
2. 抽象方法和抽象类都必须被abstract 关键字修饰。
3. 抽象类不可以用new 创建对象。因为调用抽象方法没意义。
4. 抽象类中的抽象方法要被使用,必须由子类复写其所有的抽象方法后,建立子类对象调用。
如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。 */ abstract class Student
{
abstract void study(); } class BaseStudent extends Student
{
void study()
{
System.out.println("base study");
}
} class AdvStudent extends Student
{
void study()
{
System.out.println("adv study");
}
} public class AbstractDemo { public static void main(String[] args) {
// TODO Auto-generated method stub
new BaseStudent().study();
} }
09-面向对象(抽象类2).avi
package myFirstCode; /*
当多个类中出现相同功能,但是功能主体不同,
这是可以进行向上抽取。这时,只抽取功能定义,而不抽取功能主体。 抽象:看不懂 抽象类的特点:
1. 抽象方法一定定义在抽象类中
2. 抽象方法和抽象类都必须被abstract 关键字修饰。
3. 抽象类不可以用new 创建对象。因为调用抽象方法没意义。
4. 抽象类中的抽象方法要被使用,必须由子类复写其所有的抽象方法后,建立子类对象调用。
如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。 抽象类和一般类没有太大的不同。
该如何描述事物,就如何描述事物,只不过,该事物中出现了一些看不懂的东西。
这些不确定的部分,也是该事物的功能,需要明确出现。但是无法定义主体。
通过抽象方法来表示。 抽象类比一般类多个抽象函数。就是在类中可以定义抽象方法。
抽象类不可以实例化。 特殊:抽象类中可以不定义抽象方法,这样做仅仅是不让该类建立对象。 */ abstract class Student
{
abstract void study();
void sleep()
{
System.out.println("躺着");
} } abstract class ChongCiStudent extends Student
{
void study()
{
System.out.println("chongci study");
} } class BaseStudent extends Student
{
void study()
{
System.out.println("base study");
}
} class AdvStudent extends Student
{
void study()
{
System.out.println("adv study");
}
} public class AbstractDemo { public static void main(String[] args) {
// TODO Auto-generated method stub
new BaseStudent().study();
} }
10-面向对象(抽象类练习).avi
package myFirstCode; /*
假如我们在开发一个系统时需要对员工进行建模,员工包含3个属性:
姓名、工号以及工资。经理也是员工,除了含有员工的属性外,另外还有一个
将近属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。 员工类:name id pay
经理类:继承了员工,并有自己特有的bonus。
*/ class Employee {
private String name;
private String id;
private double pay; Employee(String name, String id, double pay) {
this.name = name;
this.id = id;
this.pay = pay;
}
} class Manager extends Employee
{
private int bonus;
Manager(String name,String id,double pay)
{
super(name,id,pay);
this.bonus = bonus;
}
public void work()
{
System.out.println("manager work");
}
} class Pro extends Employee
{
Pro(String name,String id,double pay)
{
super(name, id, pay);
}
public void work()
{
System.out.println("pro work");
}
} public class AbstractTest { public static void main(String[] args) {
// TODO Auto-generated method stub } }
11-面向对象(模版方法模式).avi
package myFirstCode; /*
需求:获取一段程序运行的时间。
原理:获取程序开始和结束的时间,并相减即可。 获取时间:java获取本机当前时间,System.currentTimeMillis(); 当代码完成优化后,就可以解决这类问题。
这种方式,叫做模板方法设计模式。 什么是模板方法呢?
在定义功能时,功能的一部分是确定的,但是有一部分是不确定,而确定的部分在使用不确定的部分,
那么这时就将不确定的部分暴露出去。由该类的子类去完成。 */ abstract class GetTime {
public final void getTime() { // final 避免覆盖复写
long start = System.currentTimeMillis();
runCode();
long end = System.currentTimeMillis();
System.out.println("毫秒: " + (end - start));
}
public abstract void runCode();
} class SubTime extends GetTime
{
public void runCode()
{
for (int i = 0; i < 4000; i++)
{
System.out.println(i);
}
}
} public class TemplateDemo { public static void main(String[] args) {
// TODO Auto-generated method stub
SubTime gt = new SubTime();
gt.getTime(); } }
12-面向对象(接口).avi
package myFirstCode; /*
接口:初期理解,可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的,那么该类可以通过接口的形式来表示。
class用于定义类
interface 用于定义接口 接口定义时,格式特点:
1. 接口中常见定义:常量,抽象方法。
2. 接口中的成员都有固定修饰符。
常量:public static final
方法:public abstract 记住:接口中的成员都是public的。 接口:是不可以创建对象的,因为有抽象方法。需要被子类实现,子类对接口中的抽象方法全都覆盖后,子类才可以实例化。
否则子类是一个抽象类。 */ interface Inter
{
//成员全是抽象
public static final int NUM = 3;
public abstract void show();
} class Test implements Inter
{
public void show(){}
} public class InterfaceDemo { public static void main(String[] args) {
// TODO Auto-generated method stub
Test t = new Test();
System.out.println(t.NUM);
System.out.println(Test.NUM);
System.out.println(Inter.NUM); } }
13-面向对象(接口2).avi
package myFirstCode; /*
接口:初期理解,可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的,那么该类可以通过接口的形式来表示。
class用于定义类
interface 用于定义接口 接口定义时,格式特点:
1. 接口中常见定义:常量,抽象方法。
2. 接口中的成员都有固定修饰符。
常量:public static final
方法:public abstract 记住:接口中的成员都是public的。 接口:是不可以创建对象的,因为有抽象方法。需要被子类实现,子类对接口中的抽象方法全都覆盖后,子类才可以实例化。
否则子类是一个抽象类。 接口可以被类多实现。 */ interface Inter
{
//成员全是抽象
public static final int NUM = 3;
public abstract void show();
} interface InterA
{
public abstract void method();
} class Demo
{
public void function(){}
} class Test extends Demo implements Inter,InterA
{
public void show(){}
public void method(){} } interface A
{
void methodA(); }
interface B extends A
{
void methodB();
}
interface C extends B
{
// void methodC();
} class D implements C
{
public void mothodA(){}
public void mothodB(){}
public void mothodC(){}
} public class InterfaceDemo { public static void main(String[] args) {
// TODO Auto-generated method stub
Test t = new Test();
System.out.println(t.NUM);
System.out.println(Test.NUM);
System.out.println(Inter.NUM); } }
14-面向对象(接口的特点).avi
接口是对外暴露的规则。
接口是程序的功能扩展。
接口可以用来多实现。
类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口。
接口与接口之间可以有继承关系。
15-面向对象(接口举例体现).avi
package myFirstCode; /*
abstract class Student
{
abstract void study();
void sleep()
{
System.out.println("sleep");
} abstract void smoke()
} interface Smoking
{
void smoke();
} class ZhangSan extends Student implements Smoking
{
void study(){};
public void smoke(){}
} */
abstract class Sporter
{
abstract void play();
} interface Study
{
void math();
} class LiSi extends Sporter implements Study
{ } public class InterfaceDemo2 { public static void main(String[] args) {
// TODO Auto-generated method stub } }
Java 学习 day07的更多相关文章
- JAVA学习笔记—review基本知识[反射与异常]
JAVA学习笔记—review基本知识[反射与异常] 1.异常: 1.1异常的分类: Java会将所有的异常封装成对象,其根本父类为Throwable. Throwable有两个子类:Error 和E ...
- 0037 Java学习笔记-多线程-同步代码块、同步方法、同步锁
什么是同步 在上一篇0036 Java学习笔记-多线程-创建线程的三种方式示例代码中,实现Runnable创建多条线程,输出中的结果中会有错误,比如一张票卖了两次,有的票没卖的情况,因为线程对象被多条 ...
- 0035 Java学习笔记-注解
什么是注解 注解可以看作类的第6大要素(成员变量.构造器.方法.代码块.内部类) 注解有点像修饰符,可以修饰一些程序要素:类.接口.变量.方法.局部变量等等 注解要和对应的配套工具(APT:Annot ...
- 分享篇——我的Java学习路线
虽然之前我是开发出身,但是我学习的语言是Objective-c,这个语言使用起来范围比较窄,对于自动化学习来说也是无用武之地,所以我自己学习了Java,对于一个有开发经验的人来说学习一门新语言相对来说 ...
- Java学习笔记(04)
Java学习笔记(04) 如有不对或不足的地方,请给出建议,谢谢! 一.对象 面向对象的核心:找合适的对象做合适的事情 面向对象的编程思想:尽可能的用计算机语言来描述现实生活中的事物 面向对象:侧重于 ...
- Java学习心得之 HttpClient的GET和POST请求
作者:枫雪庭 出处:http://www.cnblogs.com/FengXueTing-px/ 欢迎转载 Java学习心得之 HttpClient的GET和POST请求 1. 前言2. GET请求3 ...
- 0032 Java学习笔记-类加载机制-初步
JVM虚拟机 Java虚拟机有自己完善的硬件架构(处理器.堆栈.寄存器等)和指令系统 Java虚拟机是一种能运行Java bytecode的虚拟机 JVM并非专属于Java语言,只要生成的编译文件能匹 ...
- 0030 Java学习笔记-面向对象-垃圾回收、(强、软、弱、虚)引用
垃圾回收特点 垃圾:程序运行过程中,会为对象.数组等分配内存,运行过程中或结束后,这些对象可能就没用了,没有变量再指向它们,这时候,它们就成了垃圾,等着垃圾回收程序的回收再利用 Java的垃圾回收机制 ...
- 0028 Java学习笔记-面向对象-Lambda表达式
匿名内部类与Lambda表达式示例 下面代码来源于:0027 Java学习笔记-面向对象-(非静态.静态.局部.匿名)内部类 package testpack; public class Test1{ ...
随机推荐
- Makefile之“=”、":="、“+=”、“?=”
Makefile之“=”.":=".“+=”.“?=”中几个的区别: 1.”=“符号 =表示个变量赋值: 注意: 当变量A被赋值给变量B时(B=A),这里A可以的这条指令之前定义的 ...
- 15个最受欢迎的Python开源框架(转载)
一.Django: Python Web应用开发框架 Django是一个开放源代码的Web应用框架,由Python写成.采用了MVC的软件设计模式,即模型M,视图V和控制器C.它最初是被开发来用于管理 ...
- Spring MVC 解读——<mvc:annotation-driven/>
Spring MVC 解读——<mvc:annotation-driven/> 一.AnnotationDrivenBeanDefinitionParser 通常如果我们希望通过注解的方式 ...
- ECSHOP商品描述和文章里不加水印,只在商品图片和商品相册加水印
fckeditor\editor\filemanager\connectors\php //判断并给符合条件图片加上水印 if ($**tension == 'jpg' || $**tension = ...
- 详细解析Spring事务的配置和OpenSessionInview的作用
1.事务的特性 原子性:事务中的操作是不可分割的一部分 一致性:要么同时成功,要么同时失败(事务执行前后数据保持一致) 隔离性:并发互不干扰 持久性:事务一旦被提交,它就是一条持久 ...
- MySql中文乱码问题(3)
MySql的client是在dos界面上,然而dos界面默认的字符集编码方式是:GBK (1).MySql字符转换原理图 watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi ...
- Django——静态文件(如bootstrap)的配置
静态文件如CSS, javascript(如bootstrap), 图片等文件在django中的配置官方文档写的比较模糊,自己通过实验验证后并整理如下,以防遗忘,目前只整理了关于本地开发中的设置方式, ...
- ["1", "2", "3"].map(parseInt) 结果
// 下面的语句返回什么呢: ["1", "2", "3"].map(parseInt); // 你可能觉的会是[1, 2, 3] // 但 ...
- 数据库设计--数据流图(DFD)
1.数据流图的定义 数据流图(DFD)是结构化分析方法中使用的工具,它以图形的方式描绘数据在系统中流动和处理的过程, 因为它仅仅反映系统必须完毕的逻辑功能.所以它是一种功能模型. 在结构化开发方法中. ...
- Linux的IO栈