------- android培训、java培训、期待与您交流! ----------
面向对象,继承,多态
面向对象
面向对象相对于面向过程。都是一种思想。过程强调的功能,面向对象是过程封装进对象,强调的是拥有功能的对象。
面向对象使复杂事情简单化,使功能封装,提高了安全性。
—————————
面向对象的三大特征:
封装,继承,多态。
——————
封装:隐藏对象的属性和实现细节,仅对外提供公共访问方式。
使用方便,隔离了变化,提高了重用性和安全性。
原则:属性都隐藏,提供公共方法访问。不需要对外提供的都隐藏。
private:成员权限修饰符,私有。使成员只在本类中有效。
—————————
继承
多个类中有共有属性和功能,把共有抽取出来,存在一个类中,就是父类,多个类为子类。通过extends关键字联系。
java中只能单继承,可以多层继承,多实现。
——————
子父类中相同变量用this,super分别调用。
相同函数通过复写调用(复写要权限大于等于,静态只能复写静态)。
子类构造函数中必有一个指向父类构造函数。
默认super(),可以自己指定。
—————————
多态
当存在继承或实现关系时,父类的引用指向自己的子类对象。提高了程度的扩展性,但只能使用父类的引用。
通过父类类型建立子类对象,可以把对象强制转成子类类型,以调用子类方法。
多态通过对象实现,编译时看类,运行时看对象。静态相对类存在,编译运行只看类。
—————————
变量分为成员和局部变量
成员变量存在堆内存中,作用于类中,局部变量位于栈内存中作用于定义的函数或语句中。
——————
构造函数
用于对类进行初始化。(没有定义时,系统会默认加个空参数构造函数)
构造代码块:对对象进行共享初始化。优先于构造函数执行。
构造只执行一次,进行初始化。一般函数被对象调用时执行。
——————
this,super
代表所在函数所属对象的引用。
this代表本类对象调用,super代表父类对象调用。
定义类中函数时,函数内部要用到调用该函数的对象时,用this表示。
在构造函数中调用构造函数用法为:this(参数);
static优先于对象存在。因此不能用于静态函数中。
——————
static:成员修饰符,静态。优先于对象存在,对象共享,可以不建立对象,直接类名调用。可以被非静态调用,不能在静态中调用非静态。生命周期最长,随着类存在。存在于方法区中静态方法区中。
静态用于定义共享数据,函数内部没有访问到非静态数据时,可以定义成静态函数。
静态代码块
static{}随着类的加载而执行,只对类进行一次初始化。
——————
final:修饰符,最终。可修饰类,变量,函数。
修饰的类不能被继承,变量修饰成常量,函数不能被复写。
—————————
抽象类,方法,接口
共性抽取出来,由子类实现。abstract标识。抽象类不能建立对象,有抽象方法的一定是抽象类。
接口
interface标识。方法抽象,常量。
因为不能实现,只有公有静态常量和公有抽象方法。
因为没有特有属性,可以多实现,补充了单继承的局限性。
接口是对外暴露的规则,对程序功能进行了扩展,可以多实现,接口之间可以多继承。
—————————
Object类
根类。
equals(Object obj)比较对象是否相等(比较地址值)
toString()返回该对象的字符串表示
—————————
内部类
位于另一个类中。相当于类中变量,有位置上特点和类的特点。因为位于类中,可直接调用外部类中内容。外部类只能对象访问。
位于成员位置时有成员属性,成员静态时,只能访问静态成员。内部类中有静态成员时,内部类必须静态。
局部内部类时不能有变量只能用final修饰。不能访问局部变量只能final修饰的变量
package demo;
/**
* 继承,多态,接口,内部类
* 构造函数,静态,成员。
*/
class Person
{
//成员变量,name,age
private String name;
private int age;
//静态对类进行初始化,静态中只能调用静态成员。静态可以直接类名调用。
public static String country="China";
//静态代码块只在类加载时执行一次
static
{
System.out.println("static代码块");
}
public static void show()
{
System.out.println("country-"+country);
}
//构造函数对对象进行初始化,构造代码块对对象进行共享初始化,
//只在对象建立时执行一次
{
System.out.println("country::="+country);
}
Person()
{
//没有建立构造函数时,系统会默认添加个空参数构造函数
System.out.println("Person()");
}
Person(String name)
{
//this指向对象中的引用
this.name = name;
System.out.println("name="+name);
//非静态函数中可以调用静态成员
System.out.println("country::="+country);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void speak()
{
System.out.println("name:"+name+"age:"+age);
}
public final void per()
{
System.out.println("final");
//final修饰的函数不能被复写
}
}
final class Final//final修饰的类不能被继承
{
Final()
{
System.out.println("final");
}
}
class Student extends Person
{
private int cj;
Student()
{
//子类构造函数中默认有super()指向父类构造函数
System.out.println("Student:::");
}
Student(String name,int cj)
{
//手动指定父类构造函数
super(name);
this.cj = cj;
System.out.println("cj:::"+cj);
}
public int getCj() {
return cj;
}
public void setCj(int cj) {
this.cj = cj;
}
public void speak()
//子类可以复写父类中方法
{
System.out.println("Student:::"+cj);
}
public void speakStu()
{
System.out.println("Stn");
}
//类中建立的类为内部类
class Xue
{
//成员位置上内部类可以被成员修饰符修饰
private int cj=2;
//
public void show()
{
int cj = 3;
//this调用内部类中对象成员,类名.this.调用外部类对象成员
System.out.println("3sj"+cj+"2cj"+this.cj+"Stu:cj"+Student.this.cj);
//由于内部类位于外部类范围内,可以直接调用外部类中私有属性成员
}
}
static class Xi
{
//当内部类中包涵静态时,内部类必须定义成静态。
//静态内部类中只能调用外部静态成员
public static void show()
{
System.out.println("static内部类");
}
}
public void neng()
{
//匿名内部类,通过继承或实现建立对象
new Study()
{
public void study()
{
//接口或抽象类中方法必须要实现
System.out.println("匿名内部类");
}
}.study();
}
}
interface Study
{
//接口中方法全抽象的
public abstract void study();
}
public class Demo2
{
public static void main(String[] args)
{
Person p = new Person("ppp");
p.setAge(22);
p.speak();
Person p1 = new Student("sss",13);
//父类类型指向子类对象。函数指向子类复写函数
p1.speak();
Student s = (Student)p1;
//子类对象强转成子类类型,可以调用子类特有方法
s.speakStu();
}
}
------- android培训、java培训、期待与您交流! ----------