1.类的定义
定义类其实在定义类中的成员(成员变量和成员函数)。
class Person {
String name;
int age;
void speak(){
System.out.println(“My name is " + name);
System.out.println(“I am " + age + " years of age”);
}
}
2.创建对象，使用对象
class Car// 对这类事物进行描述Car
{
String color = “red”;
int num = 4;
void show()
{
System.out.println(“color=”+color+”…num="+num);
}
}
class CarDemo
{
public static void main(String[] args)
{
Car c = new Car();//建立对象
c.color = “black”;//对对象的属性进行修改
c.show();// 使用对象的功能。
}
}
3.Java中的构造器
（1）构造器声明在类的内部
（2）构造方法名字和类名必须一样
（3）构造方法不能有返回值
（4）构造方法可以包含参数
package com.tarena.jichu.oop;
public class Point{
int x;
int y;
public Point (int x,int y){
this.x=x;
this.y=y;
}
}
4.对象实例化的过程
package com.tarena.jichu.oop;
public class PointDemo{
Point p=new Point(3,5);
Point p2=new Point(3,5);
System.out.println(p.x+":"+p2.x);
}
5.this关键字
this是当前对象的引用，是运用期间当前对象本身。
（1）可以使用this明确的访问当前对象的属性或者方法
（2）this()可调用本类的其他构造器，可以实现构造器的重用，简化代码的实现
（3）this()必须写在构造器的第一行
public class Point{
int x;//成员变量
int y;
public Point(int x,int y){
this.x=x;
this.y=y;
}
}
6.构造方法重载
public class Point{
int x;
int y;
public Point (int x){
this (x,x);
}
public Point (int x,int y){
this.x=x;
this.y=y;
}
}
7.默认构造器
public class ConstructorDemo{
public static void main(String[] args){
Foo f=new Foo();
//Goon g=new Goo();//没有Goo();
Goo g=new Goo(2);//调用构造Goo(int)
}
}
class Foo{
//public Foo();//默认构造器
}
class Goo{
int a;
//如果定义了构造器，javac不再提供默认构造器
public Goo(int a){
}
}
8.方法重载
public class Point{
int x;
int y;
public Point(int x){
//调用本类中的构造器
this(x,x);
}
//构造器
public Point (int x,int y){
this.x=x;
this.y=y;
}
//计算当前点到原点的距离
public double distance(){
return Math.sqrt(this.xthis.x+this.ythis.y);
}
//方法重载（方法名一样，参数列表不一样）
//计算当前点到某点的距离
public double distance(int x,int y){
return Math.sqrt(this.x-xthis.x-x)+(this.y-ythis.y-y);
}
//重载方法之间经常重用
public double distance(Point other){
return Math.sqrt(distance(other.x,other.y));
}
}
9.继承
方法重写
public class Person{
String name;
int age;
String sex;
public void move(){
System.out.println(“父类中的move方法”);
}
}
class Student extends Person{
double scrore;
public void move(){
System.out.println(“子类重写以后的办法”);
}
public void test(){
}
}
10.抽象类和接口
一、抽象类
/*
- 在class前加abstract关键字
/
public abstract class AbstractTest{
public abstract void delete(int id);
public abstract void update(int id);
}
class AbstractTest1 extends AbstractTest{
public void delete(int id){
}
public void update(int id){
}
}
注意：
（1）抽象类不能实例化（没有方法体）
（2）abstract修饰抽象方法，抽象方法不能有方法体
（3）包含抽象方法的类，一定是抽象类，使用abstract修饰
（4）抽象类不能直接实例化，使用抽象类概念可以声明引用变量
（5）抽象概念的引用变量可以引用具体的子类实例
（6）抽象类只能被继承，子类需要实现抽象类的抽象方法
二、接口
接口可以看成一种特殊的抽象类，特征如下：
（1）接口中所有方法都是抽象方法，且必须是抽象方法
（2）接口的所有属性都是静态常量（static final），数据成员必须初始化（不能被重新赋值）
（3）接口没有构造方法
（4）一个类可以同时实现多个接口，也可以不实现任何接口（类不能实现接口）
/ - 定义一个接口用关键字interface
- 接口中定义抽象方法不用关键字adstract
/
public interface InterfaceTest{
public void delete (int id);
public void update(int id);
}
/ - 实现一个接口用关键字implements
- 并且要实现接口中的所有抽象方法
*/
class InterfaceTest1 implements InterfaceTest{
public void delete(int id){
}
public void update(int id){
}
}
