黑马程序员_08_继承_接口

最新推荐文章于 2015-03-21 23:14:12 发布
最新推荐文章于 2015-03-21 23:14:12 发布
阅读量426 收藏
点赞数
分类专栏： java 文章标签： 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013278329/article/details/18006819
版权
 
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
 


 
0701-0701-0701-0701-0701-0701-0701-0701-0701-0701-0701-0701-0701-0701-0701-0701-
继承：
1、提高了代码的复用性。
2、让类与类之间产生了关系。有了这个关系，才有了多态。

/*
继承：
1、提高了代码的复用性。
2、让类与类之间产生了关系。有了这个关系，才有了多态。
注意：
千万不要为了获取其他类的功能、简化代码而写继承，
必须是类与类之间有所属关系才可以继承，所属关系是is a....
*/
public class Extends0701{
		public static void main(String[] args){
					
		}	
}
class Person{
		private String name;
		private int age;
		
		public void setName(String name){
				this.name=name;
		}	
		public String getName(){
				return name;
		}
		
		public void setAge(String age){
				this.age=age;
		}	
		public String getAge(){
				return age;
		}
		
		public void speak(){
				System.out.println("我是一个人");	
		}
}
/*
1、Java只支持单继承，不支持多继承。
2、因为当多个父类中定义了相同方法（方法名称相同，参数列表相同，返回值类型相同）时，
子类不能确定运行哪一个方法。
3、但是Java保留了这种机制，并用另一种体现形式来完成表示，即多实现。
*/
class Student extends Person{
		private int uuid;
		
		public void setUuid(int uuid){
				this.uuid=uuid;
		}	
		publid int getUuid(){
				return uuid	
		}
		
		public void study(){
				System.out.println("I'm studying.Don't disturb me!");	
		}
}

class Worker extends Person{
		private String company;
		
		public void setCompany(String company){
				this.company=company;
		}	
		publid String getCompany(){
				return company	
		}	
		
		public void work(){
				System.out.println("I'm workying.Don't disturb me!");	
		}
}

0704-0704-0704-0704-0704-0704-0704-0704-


public class Extends0701{
		public static void main(String[] args){
			  //加载子类之前应该先加载父类
				Student s=new Student();	
						
		}	
}
class Person{
		public String hobby;
		private String name;
		private int age;
		
		public void setName(String name){
				this.name=name;
		}	
		public String getName(){
				return name;
		}
		
		public void setAge(String age){
				this.age=age;
		}	
		public String getAge(){
				return age;
		}
		
		public void speak(){
				System.out.println("我是一个人");	
		}
}

class Student extends Person{
	  public String hobby;
		private int uuid;
		
		public void setUuid(int uuid){
				this.uuid=uuid;
		}	
		publid int getUuid(){
				return uuid	
		}
		
		public void study(){
				System.out.println("I'm studying.Don't disturb me!");	
		}
		
		public void printHobby(){
			  /*
			  如果父子类中出现了非私有的同名变量，子类要访问本类中的变量用this,子类要访问父类的同名变量要用super。
			  super的使用和this的使用几乎一致：this代表的是本类对象的引用，super代表的是父类对象的引用。
			  */
				System.out.println("student的爱好是："+this.hobby);	
				System.out.println("person的爱好是："+super.hobby);	
		}
}

class Worker extends Person{
		private String company;
		
		public void setCompany(String company){
				this.company=company;
		}	
		publid String getCompany(){
				return company	
		}	
		
		public void work(){
				System.out.println("I'm workying.Don't disturb me!");	
		}
}

0705-0705-0705-0705-0705-0705-0705-0705-

public class Extends0705{
		public static void main(String[] args){
				Student s=new Student();
				//1、当子类中有和父类相同的方法时，子类对象调用该方法运行的是子类的方法的内容，
				//如同父类的方法被覆盖了一样。这种情况是函数的另一个特性：覆盖（重写）。
				//2、覆盖Override:是指当子类对从父类继承的方法不满意时，子类可以对其进行内容修改，
				//但是原方法的方法名、返回值类型、参数列表不能改变。
				s.speak();
		}	
}
class Person{
		public void speak(){
				System.out.println("I'm a person !");	
		}	
}
/*
1、子类覆盖父类，必须保证子类的权限大于等于父类的权限，这样才可以覆盖。
2、静态只能覆盖静态
*/
class Student extends Person{
	
		public void speak(){
			  System.out.println("I'm a student..... !");	
		}	
}

0706-0706-0706-0706-0706-0706-0706-0706-

public class Extends0706{
		public static void main(String[] args){
				Student s=new Student();
				/*
				二、为什么子类的构造一定要调用父类的构造方法？
				    子类可以直接使用从父类继承的数据，但是在使用之前应该先访问父类的构造方法。
				因为父类的构造方法有可能对数据进行初始化或者修改。如果不访问父类的构造方法，
				子类得到的数据有可能是错误的。
				*/
				System.out.println("num="+num);
		}	
}
class Person{
	  int num=3;
		Person(){
			  num=33;
				System.out.println("person run !");	
		}	
		Person(int n){
				System.out.println("person run !::::"+n);	
		}
}
class Student extends Person{
	
		Student(){
			   /*
			  //1、对子类对象进行初始化时，父类的构造函数也会运行，
			  //那是因为子类的构造函数的第一行默认有一条隐式的语句：super()
			    
			  //2、super()会调用父类中的无参的构造函数
			  //3、子类中所有的构造函数的默认第一行都是super()
			    4、super()是默认的被调用的构造函数，如果想调用其他的构造函数，可以通过参数的不同，
			       手动的选择：比如，想调用另外的构造函数时，可以这样写：super(8888);
			    5、super()语句一定定义在子类构造函数的第一行。
			    6、子类构造函数的第一行要么是super()语句，要么是this()语句，两者只能二选一
			  */
			  System.out.println("student run...... !");	
			  
		}	
}

0707-0707-0707-0707-0707-0707-0707-0707-

final可以修饰类、变量、方法
1、被final修饰的类，不可以被继承，有些人称这样的类是“断子绝孙类”。
2、被final修饰的方法不可以被重写。
3、被final修饰的变量只能赋值一次，既可以修饰成员变量，又可以修饰局部变量。
  （1）、当描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便阅读。
   而这个值不需要改变，可以给这个值加上final来修饰。
	（2）、作为常量，常量的书写规范是所有的字母都要大写，如果由多个单词组成，那么单词之间用下划线(“_”)链接
4、内部类定义在类的局部位置上的时候，只能访问局部位置上被final修饰的局部变量。

0708-0708-0708-0708-0708-0708-0708-0708-

1、抽象方法一定在抽象类中。
2、抽象方法和抽象类必须得被abstract修饰。
3、抽象类不可以被new创建对象，因为调用抽象方法没有意义。
4、抽象类中的抽象方法要被使用，必须由子类复写所有的抽象方法后，建立子类对象调用。
   如果子类值覆盖了部分抽象方法，那么该子类还是抽象类。

0711-0711-0711-0711-0711-0711-0711-0711-

/*
写一个类，这个类可以获取执行一段代码所耗费的时间
原理：获取程序的开始时间和结束时间并相减即可。
*/
class GetTime{
		public void getTime(){
				long start=System.currentTimeMillis();
				
				int sum=0;
				for(int i=0;i<100000000;i++){
						sum+=i;
				}
				
				long end=System.currentTimeMillis();
				
				System.out.println("执行本段代码耗时 "+(end-start)+"毫秒");	
		}	
}

public class Template0711_01{
		public static void main(String[] args){
				GetTime gt=new GetTime();
				gt.getTime();	
		}	
}
*********************************************************************
/*
写一个类，这个类可以获取执行一段代码所耗费的时间
原理：获取程序的开始时间和结束时间并相减即可。
*/
class GetTime{
		public void getTime(){
				long start=System.currentTimeMillis();
				
				runcode();
				
				long end=System.currentTimeMillis();
				
				System.out.println("执行本段代码耗时 "+(end-start)+"毫秒");	
		}	
		public void runcode(){
				int sum=0;
				for(int i=0;i<100000000;i++){
						sum+=i;
				}	
		}
}

public class Template0711_02{
		public static void main(String[] args){
				GetTime gt=new GetTime();
				gt.getTime();	
		}	
}
*********************************************************************
/*
1、写一个类，这个类可以获取执行一段代码所耗费的时间
原理：获取程序的开始时间和结束时间并相减即可。
2、什么是模板方法？
在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定部分在使用不确定部分。
那么这时就要把不确定部分暴露出去，由该类的子类去完成。
*/
abstract class GetTime{
		public void getTime(){
				long start=System.currentTimeMillis();
				
				runcode();
				
				long end=System.currentTimeMillis();
				System.out.println("执行本段代码耗时 "+(end-start)+"毫秒");	
		}	
		//不确定的部分不一定是abstract的
		public abstract void runcode();
}
class SubGetTime extends GetTime{
		public void runcode(){
				int sum=0;
				for(int i=0;i<100000000;i++){
						sum+=i;
				}	
		}
}
public class Template0711_03{
		public static void main(String[] args){
				//GetTime gt=new GetTime();
				SubGetTime sgt=new SubGetTime();
				sgt.getTime();	
		}	
}

0712-0712-0712-0712-0712-0712-0712-0712-0712-0712-0712-0712

一、接口
	1、格式：
			interface();
	2、接口中的成员修饰符是固定的
		（1）、成员常量：public static final
		（2）、成员方法：public abstract（这些修饰符可以不写，但是最好写上，这样方便阅读）
	3、接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。
	4、初期可以这样理解：
			接口就是一个特殊的抽象类，该抽象类中的方法都是抽象方法。
	5、接口是不可以创建对象的，因为接口中有抽象方法，需要被子类实现。
	   当子类实现了所有的接口后，子类可以实例化。否则，子类是一个抽象类。
interface Inter{
		public static final int NUM=3;
		public abstract void show();	
}

class Test implements Inter{
		public void show(){
				System.out.println("Test....");	
		}	
}

public class Inter0712{
		public static void main(String[] args){
				Test t=new Test();
				System.out.println(t.NUM);	
				System.out.println(Test.NUM);	
				System.out.println(Inter.NUM);	
		}	
}

0713-0713-0713-0713-0713-0713-0713-0713-0713-0713-0713-
/*
一个类只可以继承一个类，但是可以实现多个接口.
*/
interface Inter{
		public static final int NUM=3;
		public abstract void show();	
}
interface InterA{
		public abstract void show();	
}
class Demo{
    public int add(int a,int b){
    		return a+b;
    }	
}
class Test extends Demo implements Inter,InterA{
		public void show(){
				System.out.println("Test....");	
		}	
}
public class Inter0712{
		public static void main(String[] args){
				Test t=new Test();
				System.out.println(t.NUM);	
				System.out.println(Test.NUM);	
				System.out.println(Inter.NUM);	
		}	
}
******************************************************************
/*
接口与接口之间存在多继承
*/
interface InterA{
		public abstract void showA();	
}
interface InterB{
		public abstract void showB();	
}
interface InterC extends InterA,InterB{
		public abstract void showC();	
}

public class Inter0713_02 implements InterC{
	  public static void main(String[] args){
				
	  }
	  public void showA(){
				
		}	
		public void showB(){
			
		}	
		public void showC(){
			
		}	
}

0714-0714-0714-0714-0714-0714-0714-0714-0714-0714-0714-0714-0714-0714-0714-
接口的特点：
1、接口是对外暴露的规则。
2、接口是程序的扩展功能。
3、接口可以用来多实现。
4、类与接口是实现关系，类在继承一个类的同时可以实现多个接口。
5、接口与接口之间可以有继承关系。






---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------







ChongXiaoFan
关注
专栏目录
【转】ROI Align 在 R-FCN 中的推广：Position Sensitive ROI Align
lanyuxuan100的博客
12-27 2049
转自：http://blog.leanote.com/post/afanti.deng@gmail.com/Position-Sensitive 1. Position Sensitive ROI-Pooling 简介 　　Position Sensitive ROI Pooling（位置敏感的候选区域池化）是检测框架R-FCN的主要创新点。一般来讲，网络越深，其具有的平移旋转不变性越
CUDA之同步函数详解
Bruce_0712的博客
03-22 2万+
之前在写程序的时候，经常用弄混同步函数，现做出总结。 _syncthreads（）：线程块内线程同步；保证线程会肿的所有线程都执行到同一位置； 当整个线程块走向同一分支时才可以使用_syncthreads()，否则造成错误；一个warp内的线程不需要同步；即当执行的线程数小于warpsize时，不需要同步函数，调用一次至少需要四个时钟周期，一般需要更多时钟周期，应尽量避免使用。
java输出二进制，八进制，十六进制数
热门推荐
zhuiyizhuiyi的专栏
01-19 4万+
System.out.printf("%010x\n",x);//按10位十六进制输出，向右靠齐，左边用0补齐 System.out.printf("%010o\n",x);//按10位八进制输出，向右靠齐，左边用0补齐 将得到以下输出 000000000f 0000000017 System.out.printf("%x\n",x);//按10位16进制输出，向右靠齐，左边用0补齐
Java程序输出一个整数的二进制，八进制，十六进制数
vincent890120的专栏
11-11 4132
System.out.println("二进制:" + Integer.toBinaryString(n));   System.out.println("八进制:" + Integer.toOctalString(n));   System.out.println("十六进制:" + Integer.toHexString(n));
黑马程序员__面向对象之继承
Wei__yaoyao的专栏
03-04 605
黑马程序员——面向对象之继承 -------android培训、java培训、期待与您交流！ ---------- 1.        继承 定义：一个类属于（从属关系）另一个类，这两个类就可以定义为继承关系。 格式：class 子类extends 父类{} 好处： （1）      大大的减少了重复代码的出现，提高了代码的复用性； （2）      通过继承，提高了父类的扩展
黑马程序员_Java继承和接口
u013700004的专栏
02-24 559
继承 继承的概述  /* 将学生和工人的共性描述提取出来，单独进行描述， 只要让学生和工人与单独描述的这个类型有关系，就可以了。 继承： 1.提高了代码的复用性。 2.让类与类之间产生了关系，有了这个关系，才有了多态的特性。 注意： 千万不要为了获取其它类的功能，简化代码而继承。 必须是类与类之间有所属关系才可以继承. java语言中：java只支持单继承，不支持多继承。 因为多继
黑马程序员_继承与多态
xiong910627的专栏
08-24 343
---------- android培训、java培训、期待与您交流！ ----------   1. 继承的概述 多个类中存在相同属性和行为时，将这些内容抽取到 单独一个类中，那么多个类无需再定义这些属性和行 为，只要继承单独的那个类即可。 多个类可以称为子类，单独这个类称为父类或者超类。 子类可以直接访问父类中的非私有的属性和行为。 通过extends 关键字让类与类之
黑马程序员_日记4_Java继承，抽象类和接口
itheima_1llt的专栏
03-21 504
——- android培训、java培训、期待与您交流！ ———-继承一、继承的概述继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。 Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，
黑马程序员_面向对象Part2 继承多态和接口
limumu100的专栏
06-20 434
------- android培训、java培训、期待与您交流！ ----------   继承： 1、提高了代码的复用性。 2、让类与类之间产生了关系。有了这个关系，才有了多态的特性。 Java语言中：java只支持单继承，不支持多继承。因为多继承容易带来安全隐患:当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。但是java保留这种机制。并用另一种体现形式
黑马程序员_超全面的JavaWeb教程-视频+源码笔记
08-29
### 黑马程序员_超全面的JavaWeb教程-视频+源码笔记 #### JavaWeb基础知识概览 在深入了解本教程之前，我们先来简要回顾一下JavaWeb的基础知识。JavaWeb是利用Java语言开发Web应用的技术集合。它主要包括Servlet、...
黑马程序员_张孝祥_Java多线程与并发库 视频+代码+资料
10-29
- 继承`Thread`类：创建一个新类继承自`Thread`类，并重写`run()`方法。 - 实现`Runnable`接口：定义一个实现了`Runnable`接口的类，并实现其中的`run()`方法，然后将其作为参数传递给`Thread`类的构造函数。 3. ...
黑马程序员_毕向东最新经典Java基础视频
03-30
根据提供的文件信息，我们可以推断出这是一套由知名IT教育机构“黑马程序员”出品、由讲师毕向东主讲的Java基础教学视频。由于实际视频内容无法直接获取，本篇将依据标题、描述以及部分标签内容，综合分析并展开相关...
黑马程序员_Java基础辅导班教程课件[第01期]第15天
01-11
《黑马程序员_Java基础辅导班教程课件[第01期]第15天》是针对初学者设计的一堂深入浅出的Java编程课程，旨在帮助学员巩固和深化Java基础知识。这堂课件涵盖的内容广泛且实用，对于想要在IT行业中开启Java开发旅程的...
01_黑马程序员_张孝祥_Java基础加强_课程价值与目标介绍.zip
09-03
【标题】"01_黑马程序员_张孝祥_Java基础加强_课程价值与目标介绍.zip" 提供的是一门由黑马程序员机构推出的Java基础强化课程，由讲师张孝祥主讲，旨在深入讲解Java编程的基础知识并进行能力提升。 【描述】中提到...
黑马程序员_03_标示符_常量_进制_变量_类型转换
u013278329的专栏
12-31 673
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------   0201-0201-0201-0201-0201-0201-0201-0201-0201-0201-0201-0201-0201-0201-0201-0201-0201-0201-0201-0201-0201 一、标
黑马程序员_04_算术_转移_逻辑_位_三元_运算符_判断语句
u013278329的专栏
01-01 527
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------   0209-0209-0209-0209-0209-0209-0209-0209- 1、算数运算符：     运算 运算符  范例   结果      正号：+       负号：- 加
黑马程序员_07_static_main_工具类_static代码块_单例模式
u013278329的专栏
01-07 517
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------   0601-0601-0601-0601-0601-0601-0601-0601-0601-0601-0601-0601-0601-0601-0601-0601-0601-0601-0601-0601-0601-
黑马程序员_10_成员变量_成员方法_静态成员方法_在多态情况下的特点
u013278329的专栏
01-10 508
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------   *****************************************************11111111111111**************************************
2018黑马程序员Java面试宝典：涵盖JavaSE与最新框架
"最新版的Java程序员面试宝典是由黑马程序员在2018年发布，涵盖JavaSE和JavaEE的基础知识以及最新的框架，旨在帮助求职者准备面试，包含了一系列常见的面试题目。" 该面试宝典是Java程序员面试的重要参考资料，内容...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值