------- android培训、java培训、期待与您交流! ----------
(day05面向对象-******************************************************************************
(概念,类与对象的关系,封装,构造函数,this)
成员变量:作用于整个类中。在堆内存中,因对象存在而存在。垃圾回收机制进行回收。
局部变量:作用于整个函数中,或语句中。栈内存中。数据用完自动释放。
@@匿名对象:
对对象方法仅进行一次调用时,
匿名对象可以作为实际参数进行传递。
new Car().color="red";
new Car().num=3;
new Car().run();
@@封装Encapsulation:隐藏对象的属性和实现细节,仅对外提供公共访问方式;
将不需要对外提供的内容都隐藏起来。
把属性都隐藏,提供公共方法对其访问。
封装--方法,类,包,框架。
private:可以用于修饰类中的所有成员,私有只在本类中有效。构造函数可以被私有化!
一个成员变量通常对应两个成员方法,set和get
私有仅仅是封装的一种表现形式。
@@构造函数:给对象进行初始化
函数名与类名相同**
不可以定义返回值类型**
不可以写return语句**
注意--1,默认构造函数 2,多个构造函数是以重载的形式存在。
3,构造函数可以被私有化!私有化后无法创建!
对象一建立就会调用与之相对应的构造函数。
当类中没有定义构造函数时,系统会默认给该类加入一个空参数的构造函数。
当类中定义了构造函数时,默认的构造函数就没有了。**
构造函数与一般函数写法上不同,运行上不同。
构造函数在对象一建立时就运行,一个对象建立构造函数就运行一次。
一般方法对象调用才执行,可以被调用多次。
当分析事物时,该事物存在就具备一些特性或者行为,那么将这些内容定义在构造函数中。
构造代码块:(放在构造函数前或后,对象一建立就运行,都先于构造函数执行!**)
{
System.out.println("nimenhao");
}
作用:给所有对象进行统一初始化,对象一建立就运行,而且优先于构造函数执行。
构造函数是给对应的对象进行初始化。
构造代码块中定义的是不同对象共性的初始化内容。
@@this
局部变量和成员变量可能重名。函数优先选择局部变量,然后是类中的成员变量。
所以构造函数中this.name = name;
this代表它所在函数所属对象的引用!哪个对象在调用this所在的函数,this就代表哪个对象!
this.变量 表示的是this对象的成员变量。
(this.函数也可以)
this应用:
1,this关键字(带.)-->当定义类中函数时,该函数内部要用到 调用该函数的对象时,用this代表这个对象。
2,this语句(不带.)-->构造函数之间的调用只能用this语句!!!**
--------this语句只能定义在构造函数的第一行(否则编译失败!)
Person(String name,int age)
{
this(name);//调用Person(String name)构造函数。
this.age = age;
}
初始化的动作要先执行,初始化之中还有初始化,就先执行初始化之中的初始化。
(day06面向对象:static,单例设计模式)******************************************************************
@@static----用于修饰成员,不能修饰局部!
被static修饰后的静态成员的特点:
随着类的加载而加载,随着类的消失而消失。说明它的生命周期最长。
javac 文件名 的时候,文件中的类会编译生成。用到某类的时候,类会加载!
优先于对象存在
被所有对象共享
可以直接被类名调用-->类名.static成员
注意:
静态方法只能访问静态成员!
静态方法中不可以写this,super关键字(因为静态方法先于对象存在。)
主函数是静态的。
String name;成员变量也叫实例变量
static String country=CN;静态的成员变量也叫类变量。
利处:对对象的共享数据进行单独空间的存储,节省空间,可以直接被类名调用。
弊处:生命周期过长,访问出现局限性(静态虽好,只能访问静态)。
静态代码块:
static
{
执行语句。
}
特点;随着类的加载而执行,只执行一次。并优先于主函数执行!用于对类进行初始化的。
@@主函数 public static void main(String[] args)
主函数是一个特殊的函数,作为程序的入口,可以被jvm调用。
public:代表着该函数的访问权限是最大的。
static:代表主函数随着类的加载就已经存在了。
void:主函数没有返回值。
main:不是关键字,但是是一个特殊的单词,可以被jvm识别,
(String[] args):函数的参数,参数类型是一个数组,数组中的元素是字符串。
就是 java demo 函数的参数 //*******
唯一可以改的是args,也就是arguments(翻译-->参数)
jvm在调用主函数时,传入的参数是 new String[0];长度为0;参数地址-->[Ljava.lang.String;@1fb8ee3
用户可以自己java demo 1 2 3 //这样的话,参数就是1 2 3,长度是3.
一个类A的编译,如果A中用到了类B,那么会先在指定目录下找B.class文件,
没有的话在指定目录下找同名的B.java文件,如果有,则先编译B.java文件。
工具类的方法一般是静态的,其构造函数是私有的。
API--application-program-interface
静态代码块:随着类的加载而执行,只执行一次。并优先于主函数执行!
static
{
语句;
}
@@笔记2,构造函数,构造代码块,静态代码块,静态成员,主函数?---顺序?
(类的加载-->指的是new新的对象时,如果new的对象为空,则不加载类;
demo d = null;时,demo没有被加载;new demo();demo被加载)
构造函数(被动):随着对象的创建而执行。
作用:给特点的类进行初始化。
构造代码块(被动):对象一建立就执行,无论放在构造函数前或后,都先于构造函数执行!
作用:给类的所有对象进行统一初始化。
静态代码块(被动):随着类的加载而执行,只执行一次。并优先于主函数执行!
所用:给类进行初始化。
主函数(被动):程序入口。
静态成员(主动):随着类的加载而加载,然后存在于方法区中,随着类的消失而消失。生命周期最长。静态函数被调用才执行。
对象的初始化过程?
Person p=new Person("wzq",22);做了哪些事情
1,因为new用到了Person.class,所以会先找到该文件,并将其加载到内存中。
2,执行该Person类中的static代码块,给Persion.class进行初始化
3,在堆内存中开辟空间,分配内存地址。(栈内存中为p开辟空间)
4,在堆内存中建立对象的特有属性(成员变量),并进行默认初始化-->private int age=0;
5,对属性进行显式初始化-->private String name = ren;
6,对对象进行构造代码块初始化;
7,对对象进行对应的构造函数初始化-->"wzq",22 初始化对象name=wzq,age=22;
8,将堆内存地址赋给栈内存中的p变量
@@单例设计模式 -->解决一个类在内存中只存在一个对象。开发建议使用饿汉式。private static demo d = new demo();
(设计模式有23个)
第一种体现
1将该类的构造函数私有化,使外部不能调用该类的构造函数,只能该类的内部调用其构造函数。
2在该类的内部自定义一个对象。
3对外提供方法进行该唯一对象的获取。
class demo//类一进内存,就已经创建好了对象。
{
private demo(){}
private static demo d = new demo();//先初始化对象--饿汉式;
public static demo getDemo()
{
return d;
}
}
第二种体现:
class demo//demo进内存,对象还没有存在,调用getDemo方法时,才创建对象。
{
private demo(){}
private static demo d = null;//后初始化对象--懒汉式;
public static demo getDemo()
{
if(d==null)
synchronized(demo.class)
{
if(d==null)
d = new demo();//对象是方法被调用时才初始化,也加对象的延时加载。
}
return d;
}
}
(day07)************************************************************************
@@继承 java只支持单继承,只能继承一个类。多继承容易带来安全隐患。
1,提高了代码的复用性
2,让类和类之间产生了关系,有了这个关系,才有了多态。
查阅父类功能,创建子类对象使用功能。
子父类中变量的特点。
Zi z = new Zi();//加载子类前,先加载父类文件。
1,变量:如果子类中出现了非私有的同名变量时,
子类要访问本类中的变量,用this;
子类要访问父类中的变量,用super;
super和this的用法几乎相同。super代表的是父类对象的引用。
2,函数:子类出现和父类一模一样的函数时,当子类调用该重名函数时,会调用子类的函数,如同父类的函数被覆盖一样。
函数的新特性:覆盖(重写)-->子类和父类中的函数完全相同,子类函数覆盖父类函数。
当子类继承了父类,沿袭了父类的功能到子类中,但是子类虽有该功能,但功能内容不一样可以使用覆盖特性,保留保留父类功能定义,重写功能内容。
@@覆盖 子类覆盖父类,必须保证子类函数权限大于等于父类函数权限,才可以覆盖,否则编译失败。
父类函数被私有后,子类不知道父类有该函数,无法覆盖。
静态只能覆盖静态,不能覆盖非静态。
函数重载:同一个类中,一个以上的同名函数,参数个数或者参数类型不同即可重载!与返回值类型无关!
函数重写:发生在子父类中,子父类方法要一模一样,包括返回值类型、参数。子类函数权限>=父类函数权限。父类该函数不能是私有的。
3,构造函数:-->子类构造函数一定会调用到父类的构造函数。
(父类有空参数的构造函数)子类构造函数首行没有显式调用super(参数)或this(?),那么所有子类构造函数首行默认隐式调用语句super();
父类没有空参数的构造函数,子类构造函数第一行必须显式调用super(参数)或this(?),因为默认的super(无参)会调用失败;
结论:子类的所有构造函数默认都会访问父类中空参数的构造函数,因为子类每一个构造函数内第一行都有一句隐式super();
当父类中没有空参数的构造函数时,子类必须手动通过super或者this来指定要访问父类中的构造函数。
@@final :修饰 类 函数 变量(成员变量或局部变量);目的是为了避免被重写!
final 类:不可以被继承-->避免被继承,避免被子类重写功能。
fianl 方法:不可以被重写。
final 变量:常量,只能被赋值一次。单词间通过_连接。
内部类定义在类中的局部位置上时,只能访问该局部被final修饰的局部变量。
@@抽象类abstract 修饰 类,方法。
有抽象方法的类就必须是抽象类,抽象类不可以实例化。强迫子类去实现抽象类中的抽象方法。
抽象类中可以不定义抽象方法,作用-->避免实例化。
abstract class demo
{
abstract void show();
......
}
1,抽象方法一定在抽象类中
2,抽象方法和抽象类都必须被abstract修饰。
3,抽象类不可以用new创建对象,因为调用抽象方法没意义。
4,抽象类中的方法要被使用,必须由子类重写所有的抽象方法后,建立子类对象调用。
模板方法模式设计模式:
在定义功能时,功能的一部分是确定的,有一部分不确定,而确定的部分在使用不确定的部分,
那么这时将不确定的部分提供出去,有该类的子类实现完成。
abstract class GetTime
{
public final void getTime()//不让重写
{
long start = System.currentTimeMillis();
runCode();
long end System.currentTimeMillis();
}
public abstract void runCode();//必须重写
}
@@接口: 内部全是抽象方法的抽象类!成员都是public
1,接口中常见定义:修饰符固定!
public static final 类型 常量;-->也可以写 类型 常量;
public abstract void 抽象方法--> void 抽象方法。
接口中自动给成员中补写:public static final 常量;
public abstract 抽象函数;
2,接口不能new,必须子类将其所有抽象类重写后,子类才能实例化。
3,接口编译后也是class文件。
4,接口可以多实现。class Demo1 extends Demo2 implements Demo3,Demo4
5,接口之间可以继承。还可以多继承。interface A extends B,C