软件世界网 购物 网址 三丰软件 | 小说 美女秀 图库大全 游戏 笑话 | 下载 开发知识库 新闻 开发 图片素材
多播视频美女直播
↓电视,电影,美女直播,迅雷资源↓
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓
一键清除垃圾
↓轻轻一点,清除系统垃圾↓
图片批量下载器
↓批量下载图片,美女图库↓
移动开发 架构设计 编程语言 Web前端 互联网
开发杂谈 系统运维 研发管理 数据库 云计算 Android开发资料
  软件世界网 -> 编程语言 -> 8面向对象(制作帮助文档,通过JDK提供的API学习了Math类,代码块,继承(继承子父成员访问特点,super关键字,方法重写)) -> 正文阅读

[编程语言]8面向对象(制作帮助文档,通过JDK提供的API学习了Math类,代码块,继承(继承子父成员访问特点,super关键字,方法重写))

1:如何制作帮助文档(了解)


       (1)写一个类
       (2)加入文档注释
       (3)通过javadoc工具生成即可
              javadoc-d 目录 -author-version ArrayTool.java
        .目录:就可以写一个文件夹的路径

2:通过JDK提供的API学习了Math类(掌握)


       (1)API(ApplicationProgramming Interface)
              应用程序编程接口(帮助文档)
       (2)如何使用呢?
             
1:打开帮助文档
2:点击显示,找到索引,看到输入框
3:知道你要找谁?以Scanner举例
4:在输入框里面输入Scanner,然后回车
5:看包
	java.lang包下的类不需要导入,其他的全部需要导入。
	
	要导入:
	java.util.Scanner
6:再简单的看看类的解释和说明,别忘了看看该类的版本
7:看类的结构
	成员变量	字段摘要 	
	构造方法	构造方法摘要 
	成员方法 	方法摘要
8:学习构造方法	
	A:有构造方法	就创建对象
	B:没有构造方法	成员可能都是静态的
9:看成员方法
	A:左边
		是否静态:如果静态,可以通过类名调用
		返回值类型:人家返回什么,你就用什么接收。
	B:右边
		看方法名:方法名称不要写错
		参数列表:人家要什么,你就给什么;人家要几个,你就给几个

       (3)Math类
              A:是针对数学进行操作的类
              B:没有构造方法,因为它的成员都是静态的
              C:产生随机数
                     publicstatic double random(): [0.0,1.0) 该值大于等于 0.0 且小于 1.0
              D:如何产生一个1-100之间的随机数
                     intnumber = (int)(Math.random()*100)+1;
              E:猜数字小游戏
/*
	猜数字小游戏(数据在1-100之间)
	
	分析:
		A:程序产生一个随机数。(被猜的)
		B:键盘录入数据。(你猜的)
		C:把你猜的和被猜的进行比较
			a:大了
			b:小了
			c:猜中了
		D:给出多次猜的机会,猜中就结束。
			while()循环,猜中就break
*/
import java.util.Scanner;

class GuessNumber {
	public static void main(String[] args) {
		//程序产生一个随机数。(被猜的)
		int number = (int)(Math.random()*100)+1;
		//System.out.println(number);
		
		//给出多次猜的机会,猜中就结束。
		while(true) {
			//键盘录入数据。(你猜的)
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入你要猜的数据(1-100):");
			int guessNumber = sc.nextInt();
			
			//把你猜的和被猜的进行比较
			if(guessNumber > number) {
				System.out.println("你猜的数据"+guessNumber+"大了");
			}else if(guessNumber < number) {
				System.out.println("你猜的数据"+guessNumber+"小了");
			}else {
				System.out.println("恭喜你,猜中了");
				break;
			}
		}
	}
}

 

3:代码块(理解)


       (1)用{}括起来的代码。
       (2)分类:
              A:局部代码块
                     局部位置,用于限定变量的生命周期,及早释放,提高内存利用率。
              B:构造代码块
                     在类中的成员位置方法外,把多个构造方法中相同的代码可以放到这里,对对象进行初始化,每个构造方法执行前,首先执行构造代码块。
              C:静态代码块
                     对类的数据进行初始化,仅仅只执行一次。

D:同步代码块

       (3)静态代码块,构造代码块,构造方法的顺序问题?
              静态代码块 > 构造代码块 > 构造方法

静态代码块只执行一次  构造代码块每次调用构造方法都执行

      

4:继承(掌握)


       (1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系,
          这多个类就具备了这些内容。这个关系叫继承。
       (2)Java中如何表示继承呢?格式是什么呢?
              A:用关键字extends表示
              B:格式:
                     class子类名 extends 父类名 {}
       (3)继承的好处:
              A:提高了代码的复用性
              B:提高了代码的维护性
              C:让类与类产生了一个关系,是多态的前提
       (4)继承的弊端:
              A:让类的耦合性增强。这样某个类的改变,就会影响其他和该类相关的类。
                     原则:低耦合,高内聚。
                     耦合:类与类的关系
                     内聚:自己完成某件事情的能力
              B:打破了封装性
       (5)Java中继承的特点
              A:Java中类只支持单继承
              B:Java中可以多层(重)继承(继承体系)
       (6)继承的注意事项:
              A:子类不能继承父类的私有成员
              B:子类不能继承父类的构造方法,但是可以通过super去访问
              C:不要为了部分功能而去继承
       (7)什么时候使用继承呢?
              A:继承体现的是:is a的关系。
              B:采用假设法
.如果有两个类A,B。只要它们符合A是B的一种,或者B是A的一种,就可以考虑使用继承。
       (8)Java继承中的成员关系
              A:成员变量
                     a:子类的成员变量名称和父类中的成员变量名称不一样,正常访问
                     b:子类的成员变量名称和父类中的成员变量名称一样,这个怎么访问呢?
                            子类的方法访问变量的查找顺序:
                                   在子类方法的局部范围找,有就使用。
                                   在子类的成员范围找,有就使用。
                                   在父类的成员范围找,有就使用。
                                   找不到,就报错。
              B:构造方法
                     a:子类的构造方法默认会去访问父类的无参构造方法
                            因为子类会继承父类中的数据,可能还会使用父类的数据

   .所以,子类初始化之前,一定要先完成父类数据的初始化



   .PS:子类每一个构造方法的第一条语句默认都是:super();


                     b:父类中如果没有无参构造方法,怎么办?
                            子类通过super去明确调用带参构造
                            子类通过this调用本身的其他构造,但是一定会有一个去访问了父类的构造
                            让父类提供无参构造

PS:this(...)或者super(...)必须出现在第一条语句上,如果不是放在第一条语句上,



.就可能对父类的数据进行了多次初始化,所以必须放在第一条语句上

              C:成员方法
                     a:子类的成员方法和父类中的成员方法名称不一样,这个太简单
                     b:子类的成员方法和父类中的成员方法名称一样,这个怎么访问呢?
                            通过子类对象访问一个方法的查找顺序:
                                   在子类中找,有就使用
                                   在父类中找,有就使用
                                   找不到,就报错
       (9)方法重写

两个面试题:

              A:Override和Overload的区别?Overload是否可以改变返回值类型?

Override:方法重写

Overload:方法重载

方法重写:

       在子类中,出现和父类中一模一样的方法声明的现象。

      PS:方法重写的注意事项
A:父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
B:子类重写父类方法时,访问权限不能更低
最好就一致
C:父类静态方法,子类也必须通过静态方法进行重写
其实这个算不上方法重写,但是现象确实如此,因为静态和类相关,算不上重写,

子类重写父类方法的时候,最好声明一模一样。

方法重载:

       同一个类中,出现的方法名相同,参数列表不同的现象。

              B:this和super的区别和各自的作用?

     .this代表本类对应的引用。


                     super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)
 
                     使用
                     A:调用成员变量
                            this.成员变量 调用本类的成员变量
                            super.成员变量 调用父类的成员变量
                     B:调用构造方法
                            this(...)    调用本类的构造方法
                            super(...) 调用父类的构造方法
                     C:调用成员方法
                            this.成员方法 调用本类的成员方法
                            super.成员方法 调用父类的成员方法
       (10)数据初始化的面试题
              A:一个类的初始化过程
/*
	看程序写结果:
		A:成员变量	就近原则
		B:this和super的问题
			this访问本类的成员
			super访问父类的成员
		C:子类构造方法执行前默认先执行父类的无参构造方法
		D:一个类的初始化过程
			成员变量进行初始化
				默认初始化
				显示初始化
				构造方法初始化
				
	结果:
		fu
		zi
		30
		20
		10
*/
class Fu{
	public int num = 10;
	public Fu(){
		System.out.println("fu");
	}
}
class Zi extends Fu{
	public int num = 20;
	public Zi(){
		System.out.println("zi");
	}
	public void show(){
		int num = 30;
		System.out.println(num); //30
		System.out.println(this.num); //20
		System.out.println(super.num); //10
	}
}
class ExtendsTest {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.show();
	}
}

              B:子父类的构造执行过程
/*
	看程序写结果:
		A:一个类的静态代码块,构造代码块,构造方法的执行流程
			静态代码块 > 构造代码块 > 构造方法
		B:静态的内容是随着类的加载而加载
			静态代码块的内容会优先执行
		C:子类初始化之前先会进行父类的初始化
		
	结果是:
		静态代码块Fu
		静态代码块Zi
		构造代码块Fu
		构造方法Fu
		构造代码块Zi
		构造方法Zi
*/
class Fu {
	static {
		System.out.println("静态代码块Fu");
	}

	{
		System.out.println("构造代码块Fu");
	}

	public Fu() {
		System.out.println("构造方法Fu");
	}
}

class Zi extends Fu {
	static {
		System.out.println("静态代码块Zi");
	}

	{
		System.out.println("构造代码块Zi");
	}

	public Zi() {
		System.out.println("构造方法Zi");
	}
}

class ExtendsTest2 {
	public static void main(String[] args) {
		Zi z = new Zi();
	}
}

              C:分层初始化
/*
	看程序写结果:
		A:成员变量的问题
			int x = 10; //成员变量是基本类型
			Student s = new Student(); //成员变量是引用类型
		B:一个类的初始化过程
			成员变量的初始化
				默认初始化
				显示初始化
				构造方法初始化
		C:子父类的初始化(分层初始化)
			先进行父类初始化,然后进行子类初始化。
			
	结果:
		YXYZ
		
	问题:
		虽然子类中构造方法默认有一个super()
		初始化的时候,不是按照那个顺序进行的。
		而是按照分层初始化进行的。
		它仅仅表示要先初始化父类数据,再初始化子类数据。
*/
class X {
	Y b = new Y();
	X() {
		System.out.print("X");
	}
}

class Y {
	Y() {
		System.out.print("Y");
	}
}

public class Z extends X {
	Y y = new Y();
	Z() {
		//super
		System.out.print("Z");
	}
	public static void main(String[] args) {
		new Z(); 
	}
}

       (11)案例:
              A:学生和老师案例
                     继承前
                     继承后
              B:猫狗案例的分析和实现
/*
	猫狗案例讲解
	
	先找到具体的事物,然后发现具体的事物有共性,才提取出一个父类。
	
	猫:
		成员变量:姓名,年龄,颜色
		构造方法:无参,带参
		成员方法:
			getXxx()/setXxx()
			eat()
			palyGame()
	狗:
		成员变量:姓名,年龄,颜色
		构造方法:无参,带参
		成员方法:
			getXxx()/setXxx()
			eat()
			lookDoor()
			
	共性:
		成员变量:姓名,年龄,颜色
		构造方法:无参,带参
		成员方法:
			getXxx()/setXxx()
			eat()
			
	把共性定义到一个类中,这个类的名字叫:动物。
	动物类:
		成员变量:姓名,年龄,颜色
		构造方法:无参,带参
		成员方法:
			getXxx()/setXxx()
			eat()
			
		猫:	
			构造方法:无参,带参
			成员方法:palyGame()
		狗:
			构造方法:无参,带参
			成员方法:lookDoor()
*/
//定义动物类
class Animal {
	//姓名
	private String name;
	//年龄
	private int age;
	//颜色
	private String color;
	
	public Animal() {}
	
	public Animal(String name,int age,String color) {
		this.name = name;
		this.age = age;
		this.color = color;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	public String getColor() {
		return color;
	}
	
	public void setColor(String color) {
		this.color = color;
	}
	
	public void eat() {
		System.out.println("不要睡了,该吃饭了");
	}
}

//定义猫类
class Cat extends Animal {
	public Cat() {}
	
	public Cat(String name,int age,String color) {
		super(name,age,color);
	}
	
	public void playGame() {
		System.out.println("猫玩英雄联盟");
	}
}

//定义狗类
class Dog extends Animal {
	public Dog() {}
	
	public Dog(String name,int age,String color) {
		super(name,age,color);
	}
	
	public void lookDoor() {
		System.out.println("狗看家");
	}
}

//测试类
class ExtendsTest5 {
	public static void main(String[] args) {
		//测试猫
		//方式1
		Cat c1 = new Cat();
		c1.setName("Tom");
		c1.setAge(3);
		c1.setColor("白色");
		System.out.println("猫的名字是:"+c1.getName()+";年龄是:"+c1.getAge()+";颜色是:"+c1.getColor());
		c1.eat();
		c1.playGame();
		System.out.println("---------------");
		
		//方式2
		Cat c2 = new Cat("杰瑞",5,"土豪金");
		System.out.println("猫的名字是:"+c2.getName()+";年龄是:"+c2.getAge()+";颜色是:"+c2.getColor());
		c2.eat();
		c2.playGame();
		
		//作业:测试狗
	}
}

             
              
......显示全文...
    点击查看全文


上一篇文章      下一篇文章      查看所有文章
2016-04-03 20:43:25  
编程语言 最新文章
Java面试题(1)
ReactiveX序列——RxSwift
C++STL之ACM相关知识大全
c++中vector向量几种情况的总结(向量指针,
SSH框架整合demo
JAX
UVA
curl备忘(1)
C#机房重构——万事开头难(二)
OJ刷题
360图书馆 软件开发资料 文字转语音 购物精选 软件下载 美食菜谱 新闻资讯 电影视频 小游戏 Chinese Culture 股票 租车
生肖星座 三丰软件 视频 开发 短信 中国文化 网文精选 搜图网 美图 阅读网 多播 租车 短信 看图 日历 万年历 2018年1日历
2018-1-16 17:15:33
多播视频美女直播
↓电视,电影,美女直播,迅雷资源↓
TxT小说阅读器
↓语音阅读,小说下载,古典文学↓
一键清除垃圾
↓轻轻一点,清除系统垃圾↓
图片批量下载器
↓批量下载图片,美女图库↓
  网站联系: qq:121756557 email:121756557@qq.com  软件世界网 --