JAVA 学习第七天

最新推荐文章于 2022-07-04 11:02:12 发布

轩怡沫

最新推荐文章于 2022-07-04 11:02:12 发布

阅读量330

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/u010652938/article/details/39011743

版权

java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

继承：

<span style="color:#CC33CC;"><strong><span style="font-size:18px;">public class Person {
	private String name;
	private int age;
	
	public void setAge(int age)
	{
		this.age = age;
		return;
	}
	
	public int getAge()
	{
		return age;
	}
	
	public void setNaem(String name)
	{
		this.name = name;
	}
	
	public String getName()
	{
		return name;
	}
}
/*
 * 继承好处：
 * 1，提高了代码的复用性
 * 2，让类与类之间产生了关系，有了这个关系，才有了多态的特性
 * 
 * 
 *注意：千万不要为了获取其它类的功能，简化代码而继承；
 *必须是类与类之间有所属关系才可以继承。所属关系 is a  （谁是谁中的一员）
 *
 *java语言中只有单继承
 *因为多继承容易带来安全隐患：
 *当多个父类中定义了相同的功能时，当功能内容不相同时，不确定要运行哪一个
 *
 *但是java保留这种机制，并用另一种体现形式完成表示，多实现
 *
 *java支持多层继承
 *b extends a
 *c extends b
 *
 *如何使用一个继承体系中的功能呢？
 *想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能
 *通过了解共性功能，就可以知道该体系的基本功能
 *那么这个体系已经可以基本使用了
 *那么在具体调用时，要创建最子类的对象，为什么呢？
 *一是因为有可能父类不能创建对象，
 *二是创建子类对象可以使用更多功能，包括基本的也包括特有的
 *
 *总之，就是查阅父类，创建子对象，使用功能
 */

public class Worker extends Person {
	void work()
	{
		System.out.println("good wrok");
	}
}
public class Student extends Person {
	void study()
	{
		System.out.println("good study");
	}
}
public class fu // extends Object
{
	int num = 2;
	fu()
	{
		System.out.println("fu run");
	}
	fu(int x)
	{
		System.out.println("fu..."+x);
	}
	public void setNum(int num)
	{
		this.num = num;
	}
	public int getNum()
	{
		return num;
	}
	public void show()
	{
		System.out.println("fu");
	}
	public void speak()
	{
		System.out.println("vb");
	}
}
/*
 * 子父类出现后，类成员的特点：
 * 
 * 类中的成员:
 * 1，变量。
 * 2，函数。
 * 3，构造函数。
 * 
 * 1，变量：
 * 如果子类中出现非私有的同名变量时，
 * 子类要访问本类中的变量，用this
 * 子类要访问父类中的变量，用super
 * 
 * super和this基本一致
 * this代表的是本类对象的引用
 * super代表的是父类对象的引用
 * 
 * 2,子父类中的函数：
 * 当子类出现和父类一模一样的函数时
 * 当子类对象调用该函数，会运行子类的内容
 * 如同父类的函数覆盖一样
 * 
 * 这种情况是函数的另一个特性，重写（覆盖）
 * 
 * 当子类继承了父类，沿袭了父类的功能到子类中
 * 但是子类虽具备该功能，但功能内容却和父类的为一致
 * 这时，没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容
 * 
 * 覆盖：
 * 1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败
 * 2，静态只能覆盖静态
 * 
 * 注意：
 * 重载：只看同名函数的参数列表
 * 重写：子父类方法要一模一样
 * 
 * 3，子父类中的构造函数
 * 在对子类对象进行初始化时，父类的构造函数也会运行
 * 那是因为子类的构造函数第一行有一条隐式的语句 super()
 * super():会访问父类中空参数的构造函数而且子类中所的构造函数默第一行都是super()
 * 
 * 为什么子类中一定要访问父类的构造函数
 * 
 * 因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
 * 所以子类在对象初始化时，要先访问一下父类中的构造函数。
 * 如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
 * 
 * 注意：
 * super语句一定要定义在子类构造函数的第一行
 * 
 * 结论：
 * 子类所有的构造函数，默认都会访问父类中空参数的构造函数。
 * 因为子类的每一个构造函数的第一行都有一句隐式super();
 * 
 * 当父类中没有空参数的构造函数时， 子类必须手动通过super语句形式来指定要访问父类中的构造函数。
 * 当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，
 * 子类中至少会有一个构造函数会访问父类中的构造函数。
 */
public class zi extends fu{
	//int num = 5;
	zi()
	{
		//super();隐式，默认
		System.out.println("zi run");
	}
	zi(int x)
	{
		//super(x);手动 
		System.out.println("zi..."+x);
	}
	public void show()
	{
		super.show();
		System.out.println("zi");
	}
	public void speak()
	{
		super.speak();
		System.out.println("java");
	}
}
</span></strong></span>

final：最终。作为一个修饰符

1，可以修饰类，函数，变量

2，被final修饰的类不可以被继承，为了避免被继承，被子类复写功能

3，被final修饰的方法不可以被复写

4，被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，又可以修饰局部变量

5，内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量

**当描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便于阅读，而这个值不需要改变，所心加上final修饰，作为常量，常量的所有字母都大写，如果有多个单词组成，单词间通过"_"连接

当多个类中出现相同功能，但是功能主体不同。

这时可以进行向上抽取，只抽取功能定义，而了抽取功能主体

抽象类：

<span style="color:#CC33CC;"><strong><span style="font-size:18px;">/*
 * 当多个类中出现相同功能，但是主体功能不同，
 * 这时可以进行向上抽取，这时，只抽取功能定义，而不功能主体。
 * 
 * 抽象：看不懂。
 * 
 * 抽象类的特点：
 * 1，抽象方法一定在抽象类中。
 * 2，抽象方法和抽象类都必须被abstract关键字修饰。
 * 3，抽象类不可以用new创建对象，因为调用抽象方法没意义。
 * 4，抽象类中的方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。
 *      如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类
 *      
 * 抽象类和一般类没有太大的不同
 * 该如何描述事物，就如何描述事物，只不过，该事物出现了一些看了懂的东西。
 * 这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体。
 * 通过抽象方法来表示。
 * 抽象类比一般类多了抽象函数。就是在类中可以定义抽象方法。
 * 抽象类不可以实例化。
 * 
 * 特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象
 */
public abstract class Student {
	abstract void study();
}
public class BaseStudent extends Student {
	void study()
	{
		System.out.println("base study");
	}
}
public class AdvStudent extends Student {
	void study()
	{
		System.out.println("adv study");
	}
}
public class Welcome {

	static final double PI = 3.14;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//JOptionPane.showMessageDialog(null, "yes, it is.", "this is a reality!", JOptionPane.INFORMATION_MESSAGE);
		new BaseStudent().study();
	}
}
</span></strong></span>

小练习：

<span style="color:#CC33CC;"><strong><span style="font-size:18px;">public abstract class Employee {
	private String name;
	private String id;
	private String pay;
	
	Employee(String name, String id, String pay)
	{
		this.name = name;
		this.id = id;
		this.pay = pay;
	}
	
	public abstract void work();
}
public class Manager extends Employee {
	private int bonus;

	Manager(String name, String id, String pay, int bonus) {
		super(name, id, pay);
		this.bonus = bonus;
	}
	
	public void work()
	{
		System.out.println("manager work");
	}
}
/*
 * 假如我们在开发一个系统时需要对员工进行建模，员工包含3个属性：
 * 姓名，工号以及工资，经理也是员工，除了停含有员工的属性外，另外还有一个奖金属性，
 * 请使用继承的思想设计出员工类和经理类，要求类中提供必要的方法时行属性访问。
 * 
 * 员工类：name, id, pay
 * 经理类：继承了员工，并有自己特有的bonus
 */


public class Welcome {

	static final double PI = 3.14;
	public static void main(String[] args) {
		// TODO Auto-generated method stub	
	}
}
</span></strong></span>

模版方法

<span style="color:#CC33CC;"><strong><span style="font-size:18px;">/*
 * 模版方法设计模式
 * 
 * 什么是模版方法？
 * 在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，
 * 那么这时候就将不确定的部分暴露出去，由该类的子类去完成
 */

public abstract class GetTime {
	public final void getTime()
	{
		long st = System.currentTimeMillis();
		runcode();
		long en = System.currentTimeMillis();
		System.out.println(en-st+1+"ms");
	}
	public abstract void runcode();
}
public class SubTime extends GetTime{
	public void runcode()
	{
		for(int i = 0; i < 4000; ++i)
			System.out.println(i);
	}
}

public class Welcome {

	static final double PI = 3.14;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new SubTime().getTime();
	}
}
</span></strong></span>

接口：

<span style="color:#CC33CC;"><strong><span style="font-size:18px;">/*
 * 接口：初期理解：可以认为是一个特殊的抽象类
 *    当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示
 * class用于定义类
 * interface用于定义接口
 * 
 * 接口定义时，格式的特点：
 * 1，接口的常见定义：常量，抽象方法
 * 2，接口中的成员都有固定修饰符
 *    常量：public static final
 *    方法：public abstract
 *    
 * **接口的成员都是public的
 * 
 * 接口:是不可以创建类的，因为有抽象方法。
 * 需要被子类实现，子类对接口中的抽象方法全部都覆盖后，子类才可以实例化。
 * 否则子类是一个抽象类。
 * 
 * 接口可以被类多实现，也是对多继承不支持的转换形式，java支持多实现。
 * 
 * 类与类之间的关系是继承
 * 类与接口之间的关系是实现
 * 接口与接口之间的关系是继承
 */
public interface Inter {
	public static final int NUM = 4;//public static final 可以省略
	public abstract void show();//public 可以省略，但是阅读性差
}


public interface InterA {
	public abstract void method();
}
public class Demo {
	public void function(){}
}

public class Test extends Demo implements Inter, InterA{
	public void show(){}
	public void method(){}
}

public interface A {
	public abstract void methodA();
}

public interface B extends A{
	public abstract void methodB();
}

public interface C extends B {
	public abstract void methodC();
}

public class D implements C{
	public void methodA(){}
	public void methodB(){}
	public void methodC(){}
}

public class Welcome {

	static final double PI = 3.14;
	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);
	}
}
</span></strong></span>

接口的特点：

1，接口是对外暴露的原则

2，接口是程序的功能扩展（***）

3，接口可以用来多实现

4，类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口

5，接口与接口之间可以有多继承关系