java abstract 继承 abstract类

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的。