[TOC]
1.方法和对象的简单介绍
类的特性包含封装,继承,多态。
多个方法不能相互嵌套
可变参数必须是最后一个参数
栈里有一个缓冲区存,直接存放字符串缓冲内容,当不new创建对象时,都会先去缓冲区里面找,若没有则直接创建新的缓冲内容。
访问权限 | public | protected | default | private |
---|---|---|---|---|
本类 | 可以 | 可以 | 可以 | 可以 |
同包 | 可以 | 可以 | 可以 | 不可 |
子类 | 可以 | 可以 | 不可 | 不可 |
其他 | 可以 | 不可 | 不可 | 不可 |
2.super可以调用父类的方法,也可以调用父类的构造器(必须在构造器的第一行)
super 和 this的用法大体相通
public Child() {
//super();
}
在子类的构造器中默认包含一个父类的无参构造器,如上述代码所示
在子类中可以重写overreading父类的方法
在父类构造器中如果调用了抽象方法(调用子类抽象方法的实现),然后调用子类的构造方法。
public abstract class UseCase1 {
abstract void testAbstract();//i
UseCase1(){//(1)首先执行父类构造方法
System.out.println("before testAbstract()");
testAbstract();//如果调用了抽象方法,调用子类覆盖的方法。这里调用Atest类的testAbstract()方法
System.out.println("after testAbstarcat()");
}
public static void main(String args[]){
new Atest();
}
}
class Atest extends UseCase1{
private int i=1;//(2)使成员变量进行初始化
void testAbstract(){
System.out.println("testAbstract()"+i);
}
public Atest(){//(3)调用子类构造方法
System.out.println(i);
}
}
//输出
before testAbstract()
testAbstract()0
after testAbstarcat()
1
3.重写与多态结合使用,父类的引用指向子类的对象,一般在子类方法中加@override
this 指调用方法的对象(在方法中指的是调用该方法的那个对象)
//当对象在父类中使用到对象中方法时使用子类的方法(父类和子类中的方法名相同)
this(“参数”);会调用本类的构造器,必须在第一行,在构造器中时,不能同时使用this和super.
//属于同一个类中
public Dog() {
this("黄狗");
}
public Dog(String name) {
}
封装类
自动拆箱和装箱
自动装箱:Integer h=10;
自动拆箱:int j=new Integer(8);
Integer.parseInt(str,进制数);不加进制数,默认为10进制
当拿一个简单数据类型和一个引用数据类型比较时,会自动拆箱
记录什么时候使用封装类
Integer number=new Integer(7);
Integer number=new Integer(“45”);//用String型变量做参数
既然提供了基本类型,为什么还要使用封装类呢?
某些情况下,数据必须作为对象出现,此时必须使用封装类来将简单类型封装成对象。
- 比如,如果想使用List来保存数值,由于List中只能添加对象,因此我们需要将数据封装到封装类中再加入List。在JDK5.0以后可以自动封包,可以简写成list.add(1)的形式,但添加的数据依然是封装后的对象。
- 另外,有些情况下,我们也会编写诸如func(Object o)的这种方法,它可以接受所有类型的对象数据,但对于简单数据类型,我们则必须使用封装类的对象。
某些情况下,使用封装类使我们可以更加方便的操作数据。比如封装类具有一些基本类型不具备的方法,比如valueOf(), toString(), 以及方便的返回各种类型数据的方法,如Integer的shortValue(), longValue(), intValue()等。
基本数据类型与其对应的封装类由于本质的不同,具有一些区别:
- 基本数据类型只能按值传递,而封装类按引用传递。
- 基本类型在堆栈中创建;而对于对象类型,对象在堆中创建,对象的引用在堆栈中创建。基本类型由于在堆栈中,效率会比较高,但是可能会存在内存泄漏的问题。
基本数据类型存在内存泄露问题
方法 | 返回值 | 功能描述 |
---|---|---|
byteValue() | byte | 以byte类型返回该Integer的值 |
comepareTo(Integer anotherInter) | ||
instanceof
- if(animal instanceof Dog){
((Dog)animal).voice(“刘皎锐”);
}
判断某个对象是否是某个类产生的对象,然后进行类型的强制转换
static修饰类的属性,方法是所有对象所共有的
static修饰中不能有this,super
调用:类名.属性;类名.方法名;
静态方法
在java中定义全局变量,通常使用public static final修饰,这样的常量只能在定义时被赋值。
final
- final修饰的类是最终类,没有子类
- final修饰方法,不允许被复写(重写),效率较高。
- final修饰的变量为常量 (全部大写,中间用下划线隔开)
我们知道一个被定义的final对象引用只能指向一个唯一一个对象,不可以将它在指向其他对象,但是一个对象本身的值却是可以改变的,那么为了使一个常量正真做到不可更改,则定义为static final。这样的常量只能在定义时赋值。
public class FinalStaticData {
private static Random rand = new Random(); // 实例化一个Random类对象
// 随机产生0~10之间的随机数赋予定义为final的a1
private final int a1 = rand.nextInt(10);
// 随机产生0~10之间的随机数赋予定义为static final的a2
private static final int a2 = rand.nextInt(10);
public static void main(String[] args) {
FinalStaticData fdata = new FinalStaticData(); // 实例化一个对象
// 调用定义为final的a1
out.println("重新实例化对象调用a1的值:" + fdata.a1);
// 调用定义为static final的a2
out.println("重新实例化对象调用a1的值:" + fdata.a2);
// 实例化另外一个对象
FinalStaticData fdata2 = new FinalStaticData();
out.println("重新实例化对象调用a1的值:" + fdata2.a1);
out.println("重新实例化对象调用a2的值:" + fdata2.a2);
}
}
Object是祖类
- 重写Object的方法,判定传递值不为空。
public boolean equals(Object obj) {
if(obj!=null){
if(obj instanceof Child){
//str.equals(str1);this.id为str的,obj.id为str2的
boolean isSame=this.id==((Child)obj).id;
return isSame;
}
}
return false;//如果为空的返回值 ,必须要有所有情况返回值
}
多态
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势,很好的解决了应用程序函数同名问题。
多态有两种表现形式:重载和覆盖
//**父类**
public class Animal {
public void voice(){
sleep();
System.out.println("动物叫");
}
public void sleep(){
System.out.println("动物睡觉了");
}
}
//**猫类**
public class Cat extends Animal {
// @Override
public void voice() {
System.out.println("喵喵喵");
}
}
//**狗类**
public class Dog extends Animal {
//表示下面的方法的覆写的方法
// @Override
public void voice() {
super.voice();
System.out.println("汪汪汪");
}
public Dog(){
this("黄毛");
//调用本类的构造器必须写在第一行。
//super调用父类构造器,必须写在第一行。
}
public Dog(String color){
}
public void voice(String name){
System.out.println("看见"+name+"立刻就咬");
}
public void voice (int age ){
System.out.println("看见年轻的就摇尾巴");
}
}
//**测试类**
public class DogTest {
public static void main(String[] args) {
// Dog dog=new Dog();
// dog.voice();
// Animal animal=new Animal();
// animal.voice();
//子类中覆写(继承的时候才重写)父类的方法
//方法名称相同
//返回值类型相同
//参数列表相同
//访问修饰符不能比父类更严格
System.out.println("***************************************");
//多态: 父类的引用指向子类的对象,根据对象的不同产生的结果不同
Animal animal=new Animal();
Animal animal2=new Dog();
Animal animal3=new Cat();
animal.sleep();
animal2.voice();
((Dog)animal3).voice(18);
if(animal2 instanceof Dog){
// 判断animal2是否为狗的对象
// 强制类型 转化
((Dog)animal2).voice(18);
}
animal3.voice();
System.out.println("**********************************");
// //方法重载
// Dog dog =new Dog();
// dog.voice();
// dog.voice(20);
// dog.voice("杜永康");
//
//
}
}