this
public class This01 {
//编写一个main方法
public static void main(String[] args) {
Dog dog1 = new Dog("大壮", 3);
System.out.println("dog1的hashcode=" + dog1.hashCode());
//dog1调用了 info()方法
dog1.info();
System.out.println("============");
Dog dog2 = new Dog("大黄", 2);
System.out.println("dog2的hashcode=" + dog2.hashCode());
dog2.info();
}
}
class Dog{ //类
String name;
int age;
// public Dog(String dName, int dAge){//构造器
// name = dName;
// age = dAge;
// }
//如果我们构造器的形参,能够直接写成属性名,就更好了
//但是出现了一个问题,根据变量的作用域原则
//构造器的name 是局部变量,而不是属性
//构造器的age 是局部变量,而不是属性
//==> 引出this关键字来解决
public Dog(String name, int age){//构造器
//this.name 就是当前对象的属性name
this.name = name;
//this.age 就是当前对象的属性age
this.age = age;
System.out.println("this.hashCode=" + this.hashCode());
}
public void info(){//成员方法,输出属性x信息
System.out.println("this.hashCode=" + this.hashCode());
System.out.println(name + "\t" + age + "\t");
}
}
//假设有一个教师类 Teacher 的定义如下:
public class Teacher {
private String name; // 教师名称
private double salary; // 工资
private int age; // 年龄
}
在上述代码中 name、salary 和 age 的作用域是 private,因此在类外部无法对它们的值进行设置。
为了解决这个问题,可以为 Teacher 类添加一个构造方法,然后在构造方法中传递参数进行修改。代码如下:
// 创建构造方法,为上面的3个属性赋初始值
public Teacher(String name,double salary,int age) {
this.name = name; // 设置教师名称
this.salary = salary; // 设置教师工资
this.age = age; // 设置教师年龄
}
在 Teacher 类的构造方法中使用了 this 关键字对属性 name、salary 和 age 赋值,this 表示当前对象。
this.name=name语句表示一个赋值语句,等号左边的 this.name 是指当前对象具有的变量 name,等号右边的 name 表示参数传递过来的数值。
测试类:
创建一个 main() 方法对 Teacher 类进行测试,代码如下:
public static void main(String[] args) {
Teacher teacher = new Teacher("王刚",5000.0,45);
System.out.println("教师信息如下:");
System.out.println("教师名称:"+teacher.name+"\n教师工资:"+teacher.salary+"\n教师年龄:"+teacher.age);
}
运行该程序,输出的结果如下所示。
教师信息如下:
教师名称:王刚
教师工资:5000.0
教师年龄:45
//需求:假设定义了一个 Dog 类,这个 Dog 对象的 run( ) 方法需要调用它的 jump( ) 方法;
public class Dog {
// 定义一个jump()方法
public void jump() {
System.out.println("正在执行jump方法");
}
// 定义一个run()方法,run()方法需要借助jump()方法
public void run() {
// 使用this引用调用run()方法的对象
this.jump();
System.out.println("正在执行run方法");
}
}
测试类:
public class DogTest {
public static void main(String[] args) {
// 创建Dog对象
Dog dog = new Dog();
// 调用Dog对象的run()方法
dog.run();
}
}
说明:
1)在 run( ) 方法中调用 jump( ) 方法时是否一定需要一个 Dog 对象?
答案是肯定的,因为没有使用 static 修饰的成员变量和方法都必须使用对象来调用。
2)是否一定需要重新创建一个 Dog 对象?
不一定,因为当程序调用 run( ) 方法时,一定会提供一个 Dog 对象,这样就可以直接使用这个已经存在的 Dog 对象,而无须重新创建新的 Dog 对象。因此需要在 run() 方法中获得调用该方法的对象,通过 this 关键字就可以满足这个要求。
this 可以代表任何对象,当 this 出现在某个方法体中时,它所代表的对象是不确定的,但它的类型是确定的,它所代表的只能是当前类的实例。
只有当这个方法被调用时,它所代表的对象才被确定下来,谁在调用这个方法,this 就代表谁。
super
static
final
//属性赋值
class AA {
public final double TAX_RATE = 0.08;//1.定义时赋值
public final double TAX_RATE2 ;
public final double TAX_RATE3 ;
public AA() {//构造器中赋值
TAX_RATE2 = 1.1;
}
{//在代码块赋值
TAX_RATE3 = 8.8;
}
}
//static修饰时
class BB {
/*
如果final修饰的属性是静态的,则初始化的位置只能是
1 定义时 2 在静态代码块 不能在构造器中赋值。
*/
public static final double TAX_RATE = 99.9;
public static final double TAX_RATE2 ;
static {
TAX_RATE2 = 3.3;
}
}
//方法中使用
public class Test {
public static void main(String[] args) {
new EE().cal();
}
}
//如果类不是final类,但是含有final方法,则该方法虽然不能重写,但是可以被继承,仍然遵守继承的机制.
class DD {
public final void cal() {
System.out.println("cal()方法");
}
}
class EE extends DD { }
native
表示原生的
表示非Java语言实现的;但是使用者可以把它当做Java的方法或成员使用;
new
表示创建对象;
和构造器一起
接口(interface)
接口由全局常量和公共的抽象方法所组成;
- 一种更加特殊的“抽象类”
- 接口的所有方法是 public方法,抽象方法的abstract可以省略不写
- 接口的成员没有执行体
接口的修饰符 只能是 public 和默认,与类的修饰符是一样的;
接口中属性
- 访问形式: 接口名.属性名
- 只能是final,且是public static final修饰符; 接口中定义的变量必须初始化
接口没有构造方法,不能被实例化
接口可以继承接口,而且可以继承多个接口
接口的应用
- (1)代理模式(Proxy)
- (2)工厂模式
//接口的属性
public class Interface_01 {
public static void main(String[] args) {
new C().pX(); //0 1
}
}
interface A { // 1min 看看
int x = 0;
} //想到 等价 public static final int x = 0;
class B {
int x = 1;
} //普通属性
class C extends B implements A {
public void pX() {
//System.out.println(x); //错误,原因不明确x
//可以明确的指定x
//访问接口的 x 就使用 A.x
//访问父类的 x 就使用 super.x
System.out.println(A.x + " " + super.x);
}
}
//接口与类的关系
public class InterfaceDetail01 {
public static void main(String[] args) {
//new IA();
}
}
//1.接口不能被实例化
//2.接口中所有的方法是 public方法, 接口中抽象方法,可以不用abstract 修饰
//3.一个普通类实现接口,就必须将该接口的所有方法都实现
//4.抽象类去实现接口时,可以不实现接口的抽象方法
interface IA {
void say();//修饰符 public protected 默认 private
void hi();
}
class Cat implements IA{
@Override
public void say() {
}
@Override
public void hi() {
}
}
abstract class Tiger implements IA {
}
//多态传递
public class InterfacePolyPass {
public static void main(String[] args) {
//接口类型的变量可以指向,实现了该接口的类的对象实例
IG ig = new Teacher();
//如果IG 继承了 IH 接口,而Teacher 类实现了 IG接口,实际上就相当于 Teacher 类也实现了 IH接口,这就是所谓的 接口多态传递现象.
IH ih = new Teacher();
}
}
interface IH {
void hi();
}
interface IG extends IH{ }
class Teacher implements IG {
@Override
public void hi() {
}
}
public class InterfacePolyParameter {
public static void main(String[] args) {
//接口的多态体现
//接口类型的变量 if01 可以指向 实现了IF接口类的对象实例
IF if01 = new Monster();
if01 = new Car();
//继承体现的多态
//父类类型的变量 a 可以指向 继承AAA的子类的对象实例
AAA a = new BBB();
a = new CCC();
}
}
interface IF {}
class Monster implements IF{}
class Car implements IF{}
class AAA {
}
class BBB extends AAA {}
class CCC extends AAA {}
为什么要声明接口?
- (1)解决Java的单继承
- (2)多个不相关的类,可能具有共同的行为特征,这样的行为特征,就可以提取成一个接口; 补充了类与类之间的关系,对象与对象之间的关系,has -a 的关系,like -a的关系;
//声明
//接口就是给出一些没有显示的方法,封装到一起,到某个类要使用时,再根据具体情况把这些方法写出来
[public] interface 接口名{
// 接口体,其中可以包含定义常量和声明方法
[public] [static] [final] type constant_name = value; // 定义常量
[public] [abstract] returnType method_name(parameter_list); // 声明方法
}
//实现接口
【修饰符】 class 实现类名 implements 接口名1,接口名2。。。{
自己的属性
自己的方法
必须实现的接口的抽象方法
}
//如果继承一个类与实现接口同时存在,那么要先继承后实现
【修饰符】 class 子类 extends 父类 implements 接口名1,接口名2。。。{
}
比较
抽象类(abstract)
指一个类中没有包含足够的信息来描绘一个具体的对象;
抽象方法只有声明没有实现;
- 没有方法体
- 必须存在于抽象类中
抽象类的价值更多在于设计,设计者设计好后,让子类继承并实现抽象类;
如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法,除非它自己也声明为 abstract 类;
抽象类的本质还是类,所以可以有类的各种成员;
- 例如:非抽象方法,构造器,静态属性等
一个抽象类中,可以有 0~n 个抽象方法,以及 0~n 个具体方法。
//应用
abstract public class Template { //抽象类-模板设计模式
public abstract void job();//抽象方法
public void calculateTime() {//实现方法,调用 job 方法
//得到开始的时间
long start = System.currentTimeMillis();
job(); //动态绑定机制
//得的结束的时间
long end = System.currentTimeMillis();
System.out.println("任务执行时间 " + (end - start));
}
}
public class A extends Template{
@Override
public void job() {
long num = 0;
for (long i = 1; i <= 800000; i++) {
num += i;
}
}
}
public class B extends Template {
@Override
public void job() {
long num = 0;
for (long i = 1; i <= 50000; i++) {
num += i;
}
}
}
public class Abstract01 {
public static void main(String[] args) {
A a = new A();
a.calculateTime();
B b = new B();
b.calculateTime();
}
}
package(打包)
权限修饰符/访问修饰符
定义: 用来控制方法和属性(成员变量)的访问权限(范围);
说明:
- 只有 缺省(default)和 public 可以修饰类
- protected和private可以修饰内部类
- 可用来修饰类中属性、成员方法及类