------- android培训、java培训、期待与您交流! ----------类--就是数据类型,也可以根据自己的需求定义类型
类就是数据类型,我们可以根据需要来定义类型
类名首字母大写,如果是多个字母,则每个字母首字母大写
class 类名
{
//成员变量
//成员函数
{
//局部变量
}
}
【成员变量和局部变量的区别?】
【1. 定义位置不同:】
成员变量定义在类中,作用域为整个类;
局部变量定义在函数中,函数调用结束,局部变量消失;
【2. 内存中出现的时间不同:】
成员变量定义好后,随着其在堆内存中创建而产生;
局部变量 所属区间参与运算时,他出现在栈内存中;
【3. 生存周期不一样:】
成员变量,随着对象的出现而出现,随着对象的消失而消失。
局部变量,当所属区间参与运算时,他存在,当所属区间在运算完毕后,在内存中消失 而消失。。
【4. 默认初始化值;】
成员变量:因为都在堆内存中,所以都有默认初始化值
局部变量:没有默认的初始化值;
关于设计类需要注意
1 Java是面向对象编程语言,所有的内容必须都放在一个类里面
2 每个文件可以有多个类,但只能有一个类是public,并且文件名必须和public修饰的类名一样。jvm会为每个类生成一个字节码文件*.class
3 通常会把main函数放在一个单独的类里面,作为整个项目的启动类
4 成员变量如果不赋值有默认值,对数值类型默认值是0,boolean类型默认值为 false,对于所有的类类型默认值为null 对于局部变量没有默认值,需赋值后才可以使用
匿名对象:new car().run();
用于对对象的方法只调用一次,这样写比较简化,如果需要对对象的成员进行多次调用,那么不能用匿名对象。可以将匿名对象作为实际参数传递
一 栈(stack)与堆(heap)
都是指的内存,但是这两块内存存储数据的性能是不一样。
1 栈空间(stack):存储在栈空间的数据,处理速度比堆空间处理速度快
2 堆空间(heap):存储在堆空间的数据,处理速度比栈空间处理速度慢
栈和堆空间都是jvm自动管理,不能通过程序干预。所有基本数据类型数据【8种】都是直接被存储在栈空间中。所有的引用数据类型 数据都存储在两个地方:产生的对象(new出来的)被存储在堆空间中,把代表该对象的一个地址或是引用存储在栈空间中。
Person p=new Person();
经历了一下几个步骤
1,将person.class 加载到内存中
2,执行该类中的静态代码块(如果有)
3,对内存中开辟空间,分配地址值
4,在堆内存中遍历对象特有的属性,并进行默认初始化
5,对属性进行显示初始化
6,对对象进行构造代码块初始化
7,对对象进行对应构造函数初始化
8,将对内存地址值付给桟内存中的P变量。
代码块
静态代码块:
格式:static
{
执行语句;(其中静态代码块只执行一次。)
}
构造代码块:
格式:
{
执行语句;(构造代码块在每次创建对象是都会执行)
}
执行顺序:(优先级从高到低。)静态代码块>mian方法>构造代码块>构造方法;默认初始化>显示初始化>构造代码块>构造方法
封装
封装是指隐藏对象的属性和一些实现细节,仅对外提供必须的访问方式。封装原则是将所有属性隐藏,提供公有方法对其访问,将不需要对外提供的方法隐藏。之所以对外提供访问方式,就因为可以在访问方式中加入逻辑判断等语句,对访问的数据进行操作,提高代码安全和健壮性。函数就是Java中最小的封装体。
封装关键字:private最常用的手法就是将成员私有化之后,对外提供get或者set方法对其访问,提高了数据的安全性。
继承:
class 类A extends 类B { }
类A:子类,基类 类B:父类,超类
在原有类的基础上设计一个新的类,引入继承之后类与类之间就多了一些层级关系,这些层次关系能增加程序的灵活性
注意
1 java里面只支持单继承,即一个类只能有一个父类,但是一个类可以有多个子类。
2 java中,为所有的类设计祖先了Object,即所有的类都是Object类的直接或间接子类。
3 private内容,构造方法,不能被继承
4 在子类的构造方法中,一定会调用父类的构造方法,如果不明确调用,则系统会自动调用父类无参的构造方法,如果父类没有无参数的构造方法,程序会发生错误。也可以利用 super(必要的参数);明确调用父类的某一个构造方法,这时系统将不会再调用父类无参数构造方法。
5 super用法
this:表示当前类的一个引用 super:表示父类的一个引用
5.1 super(必要的参数),在子类的构造方法中调用父类的构造方法 注意 必须是第一条语句
5.2 当子类和父类定义了同名的成员变量或成员方法,
子父类中有同名变量时,子类如果用该变量实际使用的是定义在子类中的变量。如果在子类中如果想访问父类的内容必须用super.
多态
在程序当中的体现就是父类引用指向子类对象,前提:存在子父类关系或者是实现关系。
abstract class Animal
{
int x = 1;
abstract void eat();
}
class Dog extends Animal
{
int x = 2;
public void eat()
{
System.out.println("啃骨头!"+x);
}
public void lookHome()
{
System.out.println("看家!");
}
}
class Cat extends Animal
{
int x = 3;
public void eat()
{
System.out.println("吃鱼!");
}
public void CatchMouse()
{
System.out.println("抓老鼠!");
}
}
class DtDemo
{
public static void main(String[] args)
{
Animal a = new Dog(); //狗是动物中的一种,此处狗既扮演狗类型,又是动物中的一种
method(a);
}
public static void method(Animal a)
{
a.eat(); //<span style="font-size: 9pt; font-family: 宋体;">啃骨头!2多态中成员被对象指向</span>
}
}
多态提高了代码的扩展性,但是也有弊端:只能使用父类中的功能。
在多态中,编译时,参阅引用类型变量所属的类中是否有调用的方法,如果有编译通过,如果没有编译失败;在运行时期,参阅new出的对象中是否有调用的方法,如果有则运行,在多态中:静态及方法被所属指向,成员被对象指向
抽象方法:
没有实现的方法,只有方法声明,没有方法体的方法叫abstract抽象方法如果一个类一旦包含了抽象方法,则该类必须声明为抽象类 abstract class 类名 { }
1 只能定义抽象类的变量,不能实例化【new 】一个抽象类 。
2 抽象类中可以非抽象方法,甚至可以一个抽象方法都没有,全部都是非抽象方法
接口是一个特殊的类,接口里面只能包含static 的常量和抽象的方法
interface 接口名 {
public static final 数据类型名 常量名=值; ......
1 接口中的成员变量默认 都是public static final 可以不写; 接口中的方法默认都是public abstract 所以可以不写
class 类名 implements 接口名1,接口名2,...... { }
4 接口直接可以互相继承,并且他们是多继承的 接口1 extends 接口2 ,接口3,... { }
单例设计模式:
解决的问题:保证一个类在内存中的对象唯一性。
如何保证对象唯一性呢?
思想:
1,不让其他程序创建该类对象。
2,在本类中创建一个本类对象。
3,对外提供方法,让其他程序获取这个对象。
步骤:
1,因为创建对象都需要构造函数初始化,只要将本类中的构造函数私有化,其他程序就无法再创建该类对象;
2,就在类中创建一个本类的对象;
3,定义一个方法,返回该对象,让其他程序可以通过方法就得到本类对象。(作用:可控)
代码体现:
1,私有化构造函数;
2,创建私有并静态的本类对象;
3,定义公有并静态的方法,返回该对象。
//饿汉式
class Single{
private Single(){} //私有化构造函数。
private static Single s = new Single(); //创建私有并静态的本类对象。
public static Single getInstance(){ //定义公有并静态的方法,返回该对象。
return s;
}
}
/懒汉式:延迟加载方式。
class Single2{
private Single2(){}
private static Single2 s = null;
public static Single2 getInstance(){
if(s==null)
s = new Single2();
return s;
}
}