java day07 this关键字及继承和重写

ゝ一世哀愁。 2022-04-12 03:41 72阅读 0赞

class Person\{ //类

public Person()\{ // 构造器

## this关键字 ##

1.在java中，this关键字比较难理解，它的作用和其词义很接近

a:他在方法内部使用，即这个方法所属对象的引用

b:他在构造器内部使用，表示该构造器正在初始化对象

2.this表示当前对象，可以调用类的属性，方法和构造器

3.当在方法内需要用到调用该方法的对象时，就用this

4.当形参与成员变量重名时，如果在方法内部需要使用成员变量，必须添加this来表明该变量时类成员

5.在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性

6.this可以作为一个类中，构造器相互调用的特殊格式

7.使用this（）必须放在构造器的首行

8.使用this调用本类中其他构造器，保证至少有一个构造器是不用this的

## this的使用 ##

package com.huake.java;
    /*this:
     * 1.可以用来修饰属性，方法，构造器
     * 2.this理解为当前对象或当前正在创建的对象 ，比如：this.name,this.show();
     * 3.可以在构造器中通过this（形参）的方式显示的调用本类中其他重载的指定的构造器
     *   要求:1.在构造器内部必须声明在首行
     *       2.若一个类中有n个构造器，最多有n-1个构造器中使用了this（形参）*/
    public class TestPerson {
    	public static void main(String[] args) {
    		Person p =new Person();
    		p.setAge(13);
    		p.setName("李磊");
    		p.info();
    		System.out.println();
    		
    		Person p1=new Person("韩梅梅",23);
    		p1.info();
    	}
    
    }
    class Person{
    	private String name;
    	private int age;
    	public Person(){
    		
    	}
    	public Person(String name){
    		System.out.println("这是Person类中形参为name的构造器");
    		this.name=name;
    	}
    	public Person(int age){
    		this.age=age;
    	}
    	//this表示当前正在创建的对象  name表示形参
    	public Person(String name,int age){ 
    		//可以用来显示的调用当前类的重载的指定的构造器
    		this(name);
    		System.out.println("这是Person类中形参为name和age的构造器");
    		 
    		this.age=age;
    	}
    	//this.name表示当前对象的属性，name是形参
    	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;
    	}
    	public void eat(){
    		System.out.println("eat");
    	}
    	public void sleep(){
    		System.out.println("sleep");
    	}
    	public void info(){
    		System.out.println("name:"+this.name+"age:"+this.age);
    		this.show();
    	}
    	public void show(){
    		System.out.println("我是一个人,我的名字是："+this.name);
    	}
    }

## this的案例一 ##

package com.huake.java;
    /*
     * 编写两个类，TriAngle和TestTriAngle，其中TriAngle中声明私有的底边长base和高 height，
     * 同时声明公共方法访问私有变量，另一个类中使用这些公共方法，计算三角形面积*/
    public class TestTriAngle { //三角形
    	public static void main(String[] args) {
    		TriAngle t=new TriAngle();
    		t.setBase(3);
    		t.setHeight(4);
    		System.out.println("面积为："+t.findArea());
    	}
    
    }
    class TriAngle{
    	private double base;
    	private double height;
    	
    	public TriAngle(){
    		base=1.0;
    		height=2.0;
    	}
    	public TriAngle(double base,double height){
    		this.base=base;
    		this.height=height;
    	}
    	public double getBase(){
    		return base;
    	}
    	public double getHeight(){
    		return height;
    	}
    	public void setBase(double base){
    		this.base=base;
    	}
    	public void setHeight(double height){
    		this.height=height;
    	}
    	public double findArea(){
    		return this.base*this.height/2;
    	}
    	
    }

## this案例二 ##

package com.huake.exer;
    
    public class Boy {
    	private String name;
    	private int age;
    	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 void marry(Girl girl){
    		System.out.println("我要娶"+girl.getName());
    	}
    	public void marry(Boy boy){
    		System.out.println("我要娶"+boy.getName());
    	}
    	public void shout(){
    		if(age>22){
    			System.out.println("我到了结婚的年龄");
    		}else{
    			System.out.println("还是先谈谈恋爱吧");
    		}
    	}
    
    }
    
    
    
    
    
    package com.huake.exer;
    
    public class Girl {
    	private String name;
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    	public void marry(Boy boy){
    		System.out.println("我要嫁给："+boy.getName());
    		boy.marry(this);
    	}
    
    }
    
    
    
    
    
    package com.huake.exer;
    
    public class TestBoyGirl {
    	public static void main(String[] args) {
    	   Boy boy=new Boy();
    	   boy.setName("徐");
    	   boy.setAge(23);
    	   Girl girl=new Girl();
    	   girl.setName("张");
    	   
    	   boy.marry(girl);
    	   boy.shout();
    	   System.out.println();
    	   girl.marry(boy);
    	   
    	}
    
    }

1.JavaBean是一种java语言写成的可重用组件。

2.所谓javaBean，是指符合如下标准的java类：

a:类是公共的

b:有一个午参的公共的构造器

c:有属性，且有对应的get，set方法

3.用户可以使用javaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他javaBean、applet程序或者应用来使用这些对象。用户可以认为javaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

## 介绍package和import ##

package com.huake.java;
    /*
     *package :声明源文件所在的包，写在程序的第一行
     *每“.”一次，表示一层文件目录。
     *包名都要小写。
     *
     *
     *import：
     *1.显示的导入指定包下的类或接口
     *2.写在包的声明和源文件之间
     *3.如果需要引入多个类或接口，那么就并列写出
     *4.如果导入的类是java.lang包下的，如：System String  Math等，就不需要显示的声明
     *5.理解.*的概念，比如java.util.*;
     *6.如何处理重名类导入，如：在util包下和sql包下同时存在Date类
     *7.import static表示导入指定类的static的属性或方法
     *8.导入java.lang.* 只能导入lang包下的所有类或接口，不能导入lang的子包下的类或接口*/
    //import java.util.Scanner;
    //import java.util.Date;
    //import java.util.List;
    //import java.util.ArrayList;
    import java.util.*;
    import java.lang.System.*;
    import java.lang.reflect.Field;
    public class TestPackageImport {
    	public static void main(String[] args) {
    	   System.out.println();
    	   Scanner s=new Scanner(System.in);
    	   s.next();
    	   Date d=new Date();
    	   List list=new ArrayList();
    	   java.sql.Date d1=new java.sql.Date(53346478568674563L);
    	   Field f=null;
    	}
    
    }

## JDK中主要包的介绍 ##

JDK中主要的包介绍
    
    1. java.lang---- 包含一些Java语言的核心类，如String、 Math、 Integer、
    
          System和Thread,提供常用功能。
    
    2. java.net-- 包含执行与网络相关的操作的类和接口。
    3. java.io ---包含能提供多种输入/输出功能的类。
    
    4. java.util---包含一些实用工具类，如定义系统特性、接口的集合框架类、
    
          使用与日期日历相关的函数。
    
    95. java.text---包含了一些java格式化相关的类
    
    6. java.sql-- 包含了java进行JDBC数据库编程的相关类/接口
    
    7. java.awt---包含 了构成抽象窗口工具集(abstract window toolkits)的
    
          多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)、
    
    8. java.applet--包含applet运行所需的一 些类。

## 继承性案例 ##

package com.huake.java1;
    
    public class Graduate extends Student {
    	public void show(){
    		System.out.println("我是一个研究生");
    	}
    	
    
    }
    
    
    
    
    package com.huake.java1;
    
    public class Student extends Person{
    //	private String name;
    //	private int age;
    //	
    	public Student(){
    		
    	}
    	public Student(String name,int age){
    //		this.name=name;
    //		this.age=age;    
    		this.setName(name);
    		this.setAge(age);
    	}
    //	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 void eat(){
    //		System.out.println("吃饭");
    //	}
    //	public void walk(){
    //		System.out.println("走路");
    //	}
    	public void info(){
    
         eat();
         System.out.println("我是一个学生");
    	}
    
    }
    
    
    
    
    
    package com.huake.java1;
    
    public class Worker extends Person {
    	
    }
    
    
    
    
    package com.huake.java1;
    
    public class Person {
    	private String name;
    	private int age;
    	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 void eat(){
    		System.out.println("吃饭");
    	}
    	public void walk(){
    		System.out.println("走路");
    	}
    
    }
    
    
    
    
    package com.huake.java1;
    /*
     * 面向对象的特征二：继承性
     * 1.通过class A extends B来实现类的继承。
     *   子类：A     父类（或基类SuperClass）：B
     * 2.子类继承父类以后，父类中 声明的属性、方法，子类就可以获取到。
     * 3.当父类中有私有的属性或方法时，子类同样可以用获取得到，知识由于封装性的设计，使得子类不可以直接调用罢了
     * 子类除了通过继承、获取父类的结构之外，还可以定义自己的特有的成分
     * 
     *  extends:子类是对父类功能的拓展，明确子类不是父类的子集。
     *  4.java中类的继承只能单继承，一个类只能继承一个父类。一个父类可以有多个子类
     *  5.子类父类是相对的概念。*/
    public class TestExtends {
    	public static void main(String[] args) {
    		Student s=new Student();
    		s.eat();
    		
    		Worker w=new Worker();
    		w.eat();
    		
    		Person p =new Person();
    		p.eat();
    		s.setAge(12);
    		s.setName("张三");
    		System.out.println(s.getName()+":"+s.getAge());
    		
    		Graduate g=new Graduate();
    		g.eat();
    		g.show();
    	}
    
    }

### 案例： 定义一个ManKind类，包括成员变量int sex和int salary   方法void manOrWorman（） 根据sex的值显示“man”（sex==1）或 v 者“woman（sex==0）”   方法 void employeed（） 根据salary的值显示“no job”（salary==0）或 者“job”（salary！=0） ###

package com.huake.java2;
    /*
     定义一个ManKind类，包括成员变量int sex和int salary
     方法void manOrWorman（）  根据sex的值显示“man”（sex==1）或者“woman（sex==0）”
     方法 void employeed（）  根据salary的值显示“no job”（salary==0）或者“job”（salary！=0）
     */
    public class ManKind {
    	private int sex;
    	private int salary;
    	
    	public int getSex() {
    		return sex;
    	}
    	public void setSex(int sex) {
    		this.sex = sex;
    	}
    	public int getSalary() {
    		return salary;
    	}
    	public void setSalary(int salary) {
    		this.salary = salary;
    	}
    	
    	public void manOrWorman(){
    		if(sex==0){
    			System.out.println("women");
    		}else if(sex==1){
    			System.out.println("man");
    		}else
    			System.out.println("输入有误");
    	}
    	public void employeed(){
    		if(salary==0){
    			System.out.println("no job");
    		}else
    			System.out.println("job");
    	}
    
    }
    
    
    
    
    
    package com.huake.java2;
    
    public class Kids extends ManKind{
    	private int yearsOld;
    	
    	public int getYearsOld() {
    		return yearsOld;
    	}
    
    	public void setYearsOld(int yearsOld) {
    		this.yearsOld = yearsOld;
    	}
    
    	public void printAge(){
    	   System.out.println(this.yearsOld);
    }
    }
    
    
    
    
    
    
    package com.huake.java2;
    
    public class TestKids {
    	public static void main(String[] args) {
    		Kids k=new Kids();
    		k.setSalary(0);
    		k.setSex(1);
    		k.setYearsOld(12);
    		k.employeed();
    		k.manOrWorman();
    		k.printAge();
    	}
    
    }

### 求圆柱的体积 ###

package com.huake.java3;
    
    public class Circle {
    	private double radius;
    	public Circle(){
    		this.radius=1;
    	}
    	public double getRadius() {
    		return radius;
    	}
    	public void setRadius(double radius) {
    		this.radius = radius;
    	}
    	public double findArea(){
    		return 3.14*radius*radius;
    	}
    
    }
    
    
    
    package com.huake.java3;
    
    public class Cylinder extends Circle{
    	private double length;
    	public  Cylinder(){
    		this.length=1;
    	}
    	public double getLength() {
    		return length;
    	}
    	public void setLength(double length) {
    		this.length = length;
    	}
    	public double findVolume(){
    		return length*findArea();
    	}
    	
    
    }
    
    
    
    
    package com.huake.java3;
    
    public class TestCylinder {
    	public static void main(String[] args) {
    		Cylinder c=new Cylinder();
    		
    		System.out.println(c.findVolume());
    		c.setRadius(2);
    		c.setLength(2);
    		System.out.println(c.findVolume());
    	}
    
    }

方法的重写：

1.前提：有子类继承父类

2.子类继承父类以后，若父类的方法对子类不适用，那么子类可以对父类的方法重写（override overwrite）

3.重写的规则：1）要求子类方法的返回值类型，方法名，参数列表必须与父类的方法一样

2）子类的方法的修饰符不能小于父类的方法的修饰符

3）若父类方法抛异常，那么子类方法抛的异常类型不能大于父类的

4）子父类的方法必须同为static或者同为非static的。