Java总结第六章

本章目的

1.this关键字

2.static关键字

3.封装性

4.继承性

5.super关键字

6.四种访问权限

7.方法重写

重点:区分方法重写和方法重载,掌握基本关键字,单例设计模式


一.this关键字

1.在每个类的每个非静态方法中,都会隐含一个this引用名称,它指向调用这个方法的当前对象。若是静态则默认为调用类中的对象。this可以看做是一个对象。

2.在非静态方法中若参数名和类的某个成员变量名(属性)一样,则会采取就近原则,即会选择局部变量,则可明确使用this关键字,前面改为this.成员变量名就可被认为是成员变

量。

3.若一个构造方法中含有this(...)则他可以调用本类中其他构造方法,但this(...)必须在构造方法第一行。


二.static关键字

1.用static修饰的变量属于类,调用时不再是默认前面为this,也不用写在参数列表中。该变量对于该类的对象是公用的,只有一份,且存储区域也不一样,存在于静态区。

2.有静态区不一定有对象但是有对象一定有静态区

3.用static修饰的方法,只能直接调用本类中的其他静态变量和静态方法。静态方法中不能使用this和super关键字,否则会自相矛盾。若要在静态方法中要调用非静态对象则要

在方法中必须new一个新的对象

4.静态方法可以通过类名:如Person(不需实例化)或类的实例,如(Person.count)去访问。

5.静态代码块经常用来初始化类的静态成员变量。语法:

   static{

        // 静态代码块内容

   }

6,.在有静态代码块的Java程序中,先执行静态代码块在执行构造方法。(先执行类在执行方法)


三.封装性(私有的属性不能再外部直接访问,这就是封装)

1、封装的好处

1.1 封装之后,对于那个事物来说,看不到这个事物比较复杂的那一面,只能看到该事物简单的那一面。复杂性封装,对外提供简单的操作入口。

1.2   封装之后才会形成真正的“对象”,真正的“独立体”

1.3   封装就意味着以后的程序可以重复使用。并且这个事物应该适应性比较强,在任何场合都可以使用。

1.4   封装之后,对于事物本身,提高了安全性。【安全级别高】

2.  对类的封装性:不可在前面加private,类中的属性,方法都存在于某个类中。

3、对字段的封装的步骤:

3.1 属性私有化,使用private关键字进行修饰,private表示私有的,修饰的所有数据只能在本类中访问。

3.2 对外提供简单的操作入口,也就是说以后外部程序要想访问这些属性,必须通过这些简单的入口进行访问: 对外提供两个公开的方法,分别是get和set

第一种方式:想读取这个属性的值,读取get

第二种方式:想修改这个属性的值,修改set

set方法的命名规范:

public void setAge(int a){

age = a;

get方法的命名规范:

public int getAge(){

return age;

}

注意:对方法进行封装,不可对普通方法进行封装。

重要:单例设计模式

1.私有化构造方法

2. 在类的内部实例化该类的对象,该类的对象必须是static全局变量。

3. 编写获取该单例对象的static方法。

  “饿汉式”单例模式:当类加载到JVM(Java虚拟机)时,单例对象直接创建;

  “懒汉式”单例模式:当类加载到JVM时,并不直接创建单例对象,用户请求单例对象时(用户需要使用时),才实例化该单例对象;

下面将举例区别

package single;
/*
 * “饿汉式”单例模式:当类加载到JVM时,单例对象直接创建
 * */
public class HungrySingleInstance {
   
	// 在该类内部实例化对象
	private static HungrySingleInstance single=new HungrySingleInstance();
	
	// 私有化构造方法,防止外部实例化该类的对象
	private HungrySingleInstance(){
		
	}

	// 静态方法,获取单例对象
	public static HungrySingleInstance getSingleInstance() {
		return single;
	}
	
	
}

package single;
/*
 * “懒汉式”单例模式:当类加载到JVM时,并不直接创建单例对象,用户请求单例对象时(用户需要使用时),才实例化该单例对象
 * */
public class LazySingleInstance {
   
	// 在该类内部实例化对象
	private static LazySingleInstance single;
	
	// 私有化构造方法,防止外部实例化该类的对象
	private LazySingleInstance(){
		
	}

	// 静态方法,获取单例对象
	public static synchronized LazySingleInstance getSingleInstance() {
		if(single==null){
			System.out.println("第一次访问单例,创建......");
			single=new LazySingleInstance();
		}
		return single;
	}
	
}
package single;

public class Test {

	public static void main(String[] args) {
		HungrySingleInstance single1=HungrySingleInstance.getSingleInstance();
		HungrySingleInstance single2=HungrySingleInstance.getSingleInstance();
		System.out.println("饿汉式单例:"+(single1==single2));
		
		LazySingleInstance lazy1=LazySingleInstance.getSingleInstance();
		LazySingleInstance lazy2=LazySingleInstance.getSingleInstance();
		System.out.println("懒汉式单例"+(lazy1==lazy2));

	}

}
输出结果:

四.继承性

1、继承是面向对象三大特征之一,三大特征分别是:封装、继承、多态

2、继承“基本”的作用是:代码重用。但是继承最“重要”的作用是:有了继承才有了以后的“方法重写”和“多态机制”。

3、继承语法格式:

[修饰符列表] class 类名 extands 父类名{

              类体 = 属性 + 方法

}

4、 java语言中的继承只支持单继承,一个类不能同时继承很多类,只能继承一个类。

5、关于继承的一些术语:

B类继承A类,其中:

A类称为B的:父类、基类、超类、superclass

B类称为A的:子类、派生类、subclass(基类)

6、关于子类继承父类的问题

6.1父类私有的属性不支持继承

6.2构造方法不支持继承

6.3其他数据(方法,属性)都可以被继承

7、虽然java语言当中只支持单继承,但是一个类也可以间接继承其他类。(继承的传递性)例如:

C extands B{

}

B extands A{

}

A extands T{

}

则是,C直接继承B类,但是C类间接T类、A类。

8、java语言中假设一个类没有显示继承任何类,该类默认继承JavaSE库当中提供的java.lang.Object类。(即Object是所有类的父类)java语言中任何一个类中都有Object类的

特征。

关于继承举例如下:

package extendsdemo;

public class Father {
	int n;

	public Father() {
		System.out.println("父类无参构造");
	}

	public Father(int n) {
		this.n = n;
		System.out.println("父类带参构造");
	}

}

package extendsdemo;

public class Child extends Father {
	//private int n;

	public Child() {
		super(300);
		System.out.println("子类无参构造");
	}

	public Child(int n) {
		this.n = n;
		System.out.println("子类带参构造:"+n);
	}
	
	public int getN() {
		return n;
	}

}

package extendsdemo;

public class Test {

	public static void main(String[] args) {
		Child c=new Child();
		System.out.println("子类对象的成员变量n是:"+c.getN());

	}

}

运行结果为:

五.super关键字

1、在Java类中super用来引用父类成员。但super不是引用类型,super中储存的不是内存地址,super指向的不是父类对象

2、super代表的是当前主类对象中的父类特征

3、子类和父类中有同名属性,但要访问父类的属性就可使用super.属性。例如:子类和父类中都有name这个属性。如果要在子类中访问父类中的name属性,需要

用“super.name”。

4、创建子类对象会先调用基类的构造方法,默认调用基类无参构造方法,要调用基类其他带参构造方法,则使用super。

 5.super只能用在成员方法和构造方法中,不可用于静态方法中(同this)

 super关键字用在构造方法中时:

语法:super(实参);

作用:通过子类的构造方法去调用父类的构造方法

语法规则:一个构造方法第一行如果没有this(...);也没有显示调用super(...),则系统会默认调用super();

注意:

super(...);的调用只能放在构造方法的第一行。

super(...)和this(...)不能共存。

super(...);调用了父类的构造方法,但是并不会创建父类对象。

比较this关键字和super关键字


六.四种访问权限

private(只对本身的类可见)<[default](是默认值,包级别的访问权限,其属性对同一包中的类可见,跨包则不可见)<protected(对跨包的的子类和同一包中的类可见)

<public(对一切类可见)

注意:

1.访问成员的前提是首先能访问成员所属的类。

2.类前面什么都不加则默认为【default】。

3.类可以用public和[default]修饰,但protect不能用来修饰一个类。


七.方法重写(override)

定义:当子类继承父类时,可以从父类继承它的属性和方法,如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫做方法的重写(override)

注意:

1.前提是子类可以继承父类的这个方法

2.只能存在于子类和父类之间

3.方法名称输入参数和返回值类型一致或父类方法返回值类型若是子类方法的返回值类型的父类(如父类方法返回值类型为Object,子类为String)

4.权限不能比父类更加严格子类,权限至少要等于父类,也就是越到后面权限越大。

5.如果子类中成员变量、静态变量、静态方法和父类中成员变量、静态变量、静态方法相同,这种情况不是重写,可以认为是隐藏,在非static成员方法之间才能重写

举例:

package override;

public class Person {
    public Object getInfo(){
    	System.out.println("Person父类的getInfo()方法");
    	return "我是父类中的方法";
    }
    
    
    public  void makeMoney(){
    	System.out.println("开工厂赚钱....");
    }
}
package override
public class Student extends Person{ public String getInfo(){ System.out.println("子类方法"); return "学生的getInfo()方法"; }public void makeMoney(){ System.out.println("开互联网公司赚钱...."); } }


package override;

public class TestOverride {

	public static void main(String[] args) {
		Student stu=new Student();
        System.out.println(stu.getInfo());
	}

}


输出结果


方法重写和重载相同点和不同点见习题。

展开阅读全文

没有更多推荐了,返回首页