9-2--9-9
主要学习科目: java jsp linux oracle
java学习:
接口
学习目标:
1.接口的定义和特性
//接口是一种抽象类,只包含常量和方法,是对类的需求描述,
/*接口的作用: 通过接口实现不相关类的相同行为
通过接口指明多个类要实现的方法
通过接口了解对象的交互界面
接口的定义:
包含接口声明和接口体 [public] interface interfaceName[extends listOfSuperInterface]{....}
*/
import java.util.*;
public class EmployeeSortTest
{
public static void main(String[] args)
{
Employee[] staff = new Employee[3];
staff[0] = new Employee("Harry Hacker",35000);
staff[1] = new Employee("Carl Cracker",75000);
staff[2] = new Employee("Tony Tester",38000);
Arrays.sort(staff);
for(Employee e:staff)
System.out.println("name = "+e.getName()+",salary = "+e.getSalary());
}
}
class Employee implements Comparable<Employee>
{
public Employee(String n ,double s)
{
name = n;
salary =s;
}
public String getName()
{
return name;
}
public double getSalary()
{
return salary;
}
public void raiseSalary(double byPercent)
{
double raise = salary*byPercent/100;
salary+=raise;
}
public int compareTo(Employee other)
{
if(salary <other.salary) return -1;
if(salary>other.salary)return 1;
return 0;
}
private String name;
private double salary;
}
2.接口和抽象类
3.对象和克隆
4.接口与回调
5.内部类问题
6.如何使用内部类访问对象状态
7.内部类的特殊语法规则
8.内部类是否使用必要和安全
9.局部内部类
10.匿名内部类
11.静态内部类
jsp学习:
linux学习:
oracle学习:
public class Dog
{
private furcolor;
private weight;
private height;
public catchmouse(Mouse m)
{
...
m.scream();
}
public static void main(String[] args)
{
Dog d = new Dog();
Mouse m = new Mouse();
d.catchmouse(m);
}
}
class Mouse
{
private int furcolor;
private int weight;
private int height;
public void scream()
{
...
}
}
面向对象:一组对象互相配合通过沟通来实现特定功能
对象都有对外服务的接口
对象隐藏内部服务的实现
组件_比对象更高的层次上的抽象
类的定义:
public class Person
{
private int Id;
private int age = 12;
public void setAge(int i)
{
age = i;
}
public int getAge()
{
return age;
}
public int getId()
{
return Id;
}
}
成员变量:
可以是java语言的任何一种数据类型(基本和引用)
在java中,如果不在定义的时候初始化变量,系统自动采用默认值;
作用范围为大括号内
引用:
java中除了基本类型外所有变量类型
java中是用引用来对对象进行操作的
如何在内存中区别类和对象
类是静态的概念,代码区
对象是new出来的,位于堆内存,类的每个成员变量在不同的对象里有不同的值,方法只有一份执行时才占内存,
//new 出来的东西都放在内存的堆中
String s;//定义了一个引用,内存中开辟一个Sting类型空间
s = new String("hellow world!");//堆栈中开辟String类型空间,一个引用s将调用它,
要点: 必须使用new关键字来创建对象
使用对象(引用):成员变量或来引用对象的成员变量
使用对象(方法):方法来调用对象的方法
同一个类的对象有不同的存储空间
同一个类的所有对象共享该类的方法
抽象类:
用abstract关键字来修饰一个类时,这个类叫抽象类,
用abstract关键字来修饰一个方法时,这个类叫抽象方法
含有抽象方法的类必须被声明为抽象类,抽象方法必须被重写
抽象类不能实例化
抽象方法只声明,不能实现
abstract class Animal
{
private string name;
Animal(string name)//在创建对象初始化完毕后,释放空间
{
this.name = name;
}
public abstract void enjoy();
}
class Cat extends Animal
{
private string eyeColor;
Cat(string n,string c)//在创建对象初始化完毕后,释放空间
{
super(n);
eyesColor = c;
}
public void enjoy()
{
System.out.println("猫叫声.....")
}
}
构造方法
使用new时构造方法创造一个新的对象
构造方法定义在java类中的一个用来初始化对象的方法
构造函数与类名同且无返回值
例如 Person类的构造函数
public class Person
{
int Id;
int Age;
person(int a,int i)//在创建对象初始化完毕后,释放空间
{
Id=i;
Age = a;
}
public static void main(String[] args)
{
Person tom = new Person(1,25);
person john = new Person(2,27);
}
}
如果没有初始化,则系统将自动指定
class point
{
int x;
int y;
}//如无构造函数,则自动添加空构造函数,如果已定义构造方法,则不能调用faction()空方法
构造方法常见问题
构造方法前不能加void(void定义的为普通方法)
命名规则
类名的首字母大写
变量名方法名首字母小写
驼峰表示(后面单词首字母大写)getId()
实例1
class BirthDate //定义一个BirthDate类,数据域有day,month,year,方法有构造函数BirthDate() ,setDay() ,setMonth() ,setYear() ,getDay() ,getMonth() .getYear() ,display()
{
private int day;
private int month;
private int year;
public BirthDate(int d,int m,int y)
{
day = d;
month = m;
year = y
}
public void setDay(int d)
{
day =d;
}
public void setMonth(int m)
{
month = m;
}
public setYear(int y)
{
yera = y;
}
public int getDay()
{
return day;
}
public int getMonth()
{
return month;
}
public int getYear()
{
return year;
}
public void display()
{
System.out.println("day"+day",month"+month",yera"+year);
}
}
public class Test//包含main()方法的类,
{
public static void main(String[] args)
{
Test test = new Test();
int date=9; //在栈内存开辟date,堆内存中存储数据9;
BirthDate d1 = new BirthDate(1,1,1988);//在栈空间中开辟d1,堆空间中存储date,month,year数据
BirthDate d2 = new BirthDate(2,2,1987);//在栈空间中开辟d1,堆空间中存储date,month,year数据
test.change1(date);//栈中开辟date,将date的值传到test的方法change1中的i去,被赋值1234,方法结束时,栈中date清空,date仍为9;
test.change2(d1);//将d1地址传递给change2中的参数b,此时d1和b同地址,在方法开始执行后,b在堆中开辟date,month,year,并赋值,方法结束后,释放栈空间b,堆空间由java的垃圾回收机制处理;
test.change3(d2);//将d2地址传递给change3中的参数b,此时d2和b同地址,并将date改为22,
System.out.println("date=="+date);
d1.display();
d2.display()
}
public change1(int i)
{
i = 1234;
}
public change2(BirthDate b)
{
b = new BirthDate(2,2,2004);
}
public change3(BirthDate b)
{
b.setDay(22);
}
}//要改变对象的值,必须通过传递参数到能改变数据域的对象内部的方法参数进行;
public class Point
{
private double x;
private double y;
private double z;
public Point(double i,double j,double k)
{
x = i;
y = j;
z = k;
}
public double getDistance(Point i)
{
return sqrt((x-i.x)*(x-i.x)+(y-i.y)*(y-i.y)+(z-i.z)*(z-i.z));
}
}
public class TestPoint
{
public static void main(String args[])
{
Point i = new Point(1,2,3);
Point j = new Point(0,0,0);
System.out.println("the distance of the point i(1,2,3) and j(0,0,0) is "+i.getDistance(j));
/*此持有一个无名对象变量在堆中,并将计算的结果返回给堆中的临时变量i,方法结束后,都被释放*/
System.out.println("the distance of the point i(1,2,3) and point (2,3,4) is "+i.getDistance(new Point(2,3,4)));
}
要点: 一个java文件只有一个public在类前声明;
方法要返回类型;
方法的重载
方法的重载时指一个类中可以定义相同名字但参数不同的多个方法,调用时会根据不同的参数(个数和类型)来选择对应的方法
例子:
class Person
{
int Id;
int Age;
person(int a,int i)//在创建对象初始化完毕后,释放空间
{
Id=i;
Age = a;
}
void info()
{
System.out.println("my id is "+Id);
}
void info(String s)
{
System.out.println(s+""+Id+Age);
}
}
public class TestOverLoad
{
public static void main(String[] args)
{
Person tome = new Person(1,25);
Person john = new Person(2,27);
System.out.println("tome.id="tome.id+" tome.Age="+tome.Age);
System.out.println("john.id ="+john.id+" john.Age="+john.Age);
tom.info();
john.info("hellow");
}
}
对象的创建和使用
例子:
class Point
{
private double x,y,z;
public Point(double i,double j,double k)
{
x=i;
y=j;
z=k;
}
public void setX(double _x)
{
x=_x;
}
public void setY(double _y)
{
y=_y;
}
public void setZ(double _z)
{
z=_z;
}
public double getX()
{
return x;
}
public double getY()
{
return y;
}
public double getZ()
{
return z;
}
public double getDistance(Point i)
{
return (x-i.x)*(x-i.x)+(y-i.y)*(y-i.y)+(z-i.z)*(z-i.z);
}
}
class Circle
{
private Point o;
private double raidus;
public Circle(Point p,double r)
{
o = p;
raidus = r;
}
public Circle(double r)
{
o = new Point(0,0,0);
raidus = r;
}
public Boolean contain(Point p)
{
if(p.getDistance(o)>raidus*raidus) return false;
else return true;
}
public void setO(double x,double y,double z)
{
o.setX(x);
o.setY(y);
o.setZ(z);
}
public void setRaidus(double r)
{
raidus = r;
}
public Point getO()
{
return o;
}
public double getRaidus()
{
return raidus;
}
public double getArea()
{
return 3.14*raidus*raidus;
}
}
public class TestCircle
{
public static void main(String[] args)
{
Circle circle1 = new Circle(new Point(1,2,3),3);
Circle circle2 = new Circle(5);
System.out.println("c1("+circle1.getO().getX()+","+circle1.getO().getY()+","+circle1.getO().getZ()+")");
System.out.println("c2("+circle2.getO().getX()+","+circle2.getO().getY()+","+circle2.getO().getZ()+")");
System.out.println("circle1 area is "+circle1.getArea());
System.out.println("circle2 area is "+circle2.getArea());
}
}
this关键字
在类的方法定义中,this代表该使用方法的对象引用;
当必须指出当前使用放大的对象时谁时必须要使用this
this可以看作一个变量,它的值时当前对象的引用;
例子
public class Leaf
{
private int i = 0;
public Leaf(int i)
{
this.i=i;
}
Leaf intcreament()
{
i++;
return this;
}
public static void main(String[] args)
{
Leaf leaf = new Leaf();
leaf.intcreament().intcreament().i;
}
}
static 关键字
类中,用static声明的成员变量为静态成员变量,它为该类的公用变量,第一次使用时给初始化,该变量只有一份;
用static声明的方法为静态方法,在调用时,不会将对象的引用传奇给它,所以在static方法中不可访问非static的成员
可以通过对象引用或类名(不需实例化)访问静态成员;
例子
public class Cat
{
private static int sid=0;
private String name;
private id;
public Cat(String m)
{
name = m;
id = sid;
}
public void info()
{
System.out.println("Cat's id = "+id+",name ="+name);
public static void main(Sting[] args)
{
sid = 100;
Cat mimi = new Cat("mimi");
Cat pipi = new Cat("pipi");
mimi.info();
pipi.info();
}
}
}
package 和import语句
解决类名的命名冲突,作为java的第一条语句,指明该文件定义的类存放的包
格式: package pkg1[][.pkg2[pkg3...]];
包对应于文件系统的目录管理,package语句中,用.来知名目录的层次
例子 package com.sxt; //该文件定义的所有类放在/com/sxt目录下面
如果将一个类打包,则使用该类时,要使用类德全名;
也可以import 在文件开头来引入要使用的类;import com.lord.Cat.class
package 语句 同目录层次同;
import 语句 最后面跟类名即可;
import java.util.*;//引入java.util中所有的类；此后在本文件中可以不注明具体的包名；
如果想将一个类放入包中，在这个类的源文件的第一句话 package
必须保证类的class文件位于正确的目录下
另外的类想访问的话： 写全名或引入；写具体的类名；同一个包不需要引入
必须class文件的最上层包的父目录位于classpath下（系统的环境变量中设定，不同的项目使用不同的classpath），执行的时候也要写全包名；
执行环境必须要在classpath中；
j2sdk的一些重要包的介绍
java.lang java的核心类，如 String,Math,Integer,System,Thread,提供常用功能；（唯一一个不需要引入就能使用的包）
java.awt 抽象窗口工具集，abstract Window Toolkit 的多个类，用来组建和管理应用程序的图形界面GUI
java.Applet 包含applet所需要的一些类
java.net 执行与网络相关的操作的类
java.io 提供多种输入输出功能的类
java.util 一些使用工具集 如定义系统特性，使用与如期日历相关的函数
jar -cvf *.jar *.*,要使用jar包的文件可以将jar当作classpath设置；
如果在类文件中使用了package，就必须对应正确的实际目录
访问控制；
public private protected default
对class的权限修饰只可以用public default
public 可以在任意地方被访问
default 只可以被同一个包内部的类访问；
类的继承和控制权限
通过继承，子类可以自动拥有基类的所有成员
java是单继承
例子 class Parent
{
private int n_private = 1;
private int n_friendly = 2;
protected int n_protected = 3;
public int n_public = 4;
}
class son extends Parent
{
public info()
{
private int n_private = 10;
private int n_friendly = 20;
protected int n_protected = 30;
public int n_public = 40;
}
}
class Person
{
private String name;
private int age;
private int id;
public void setAge(int i)
{
age = i;
}
public void setName(String n)
{
name = n;
}
public void setId(int j)
{
id = j;
}
public String getName(){return name;}
public int getAge(){return age;}
public int getId(){return id;}
}
class Student extends Person
{
private String school;
public void setSchool(String s)
{
school = s;
}
public String getSchool()
{
return school;
}
}
public class Test
{
public static void main(String[] args)
{
Student s = new Student();
s.setName("john");
s.setAge(18);
s.setId(100);
s.setSchool("beida");
System.out.println("name is "+s.getName());
System.out.println("age is "+ s.getAge());
System.out.println("id is "+s.getId());
System.out.println("school is "+s.getSchool());
}
}
935
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
