this关键字

定义

在类的方法定义中使用this关键字代表使用该方法的引用.

this即"自己",代表对象本身,谁调用代表谁.在成员方法中或构造器中隐式的传递.

this的两种用法

  1. 构造器中

    1. 作用:可以调用本类中的其他构造器

    2. 具体用法可参照2.2的中的代码

  2. 成员变量与局部变量

    1. 作用:当成员变量与局部变量同名时,可以采用this关键字代指当前对象的属性(即成员变量)

    2. 具体用法:

      public class Computer01 {
      public String brand;
      public double price;
      public String color;
         //this的用法:代指当前对象的属性值
      public Computer01(String brand,double price){
      this.brand=brand;//this.brand是当前对象的属性名,brand是传入值(局部变量)
      this.price=price;
      System.out.println("带参构造器1");
      }
      public Computer01(String brand,double price,String color){
      this(brand,price);    //this的用法:调用构造器1
      this.color=color;
      System.out.println("带参构造器2");
      }
      }

注意事项

  1. this在构造器中只能放在首行

  2. 利用this关键字可以避免属性和形参 局部变量同名,发生就近原则.

    1. 就近原则:在此例中就是当局部变量与成员变量中就会先找局部变量.

  3. this([实参列表]):可以调用其他构造器

  4. this可以看做是一个变量,它的值是当前对象的引用

  5. this不能出现在被static修饰的内容中

    1. 因为this代表对象的引用,而static是在类加载的时候而此时对象还未创建.

  6. 构造方法不能相互调用,此时会造成类似死循环的效果,会报错.

  7. 当只有成员变量时,默认省略了this关键字.

static关键字

含义

在类中,用 static 声明的成员变量为静态成员变量,它为该类的公用变量,在第一次使用时被初始化,对于该类的所有对象来说,static 成员变量只有一份。凡是静态的都是属于类的,与对象无关的,先于对象存在的。可用于修饰属性、方法、块。

解释:

  1. static声明的修饰的成员变量、成员方法、块都是静态成员变量、成员方法、块。

  2. 静态在第一次使用的时候(即类加载时)就被初始化,先于对象存在。

调用方式(两种)

  1. 类名.静态属性|方法名();

  2. 对象.静态属性|方法名();

注意:

  1. 静态方法只能使用静态内容;即被static修饰的方法只能使用被static修饰的内容

  2. 类的所有对象都共用静态的内容

  3. 静态内容在类的第一次加载时就被初始化

  4. 非静态内容可以使用非静态内容也可以使用静态内容

public class StaticDemo01 {
static int id=5;//静态
int age=10;//成员变量
public static void main(String[] args) {
//类中,静态变量与成员变量的使用区别
System.out.println(StaticDemo01.id);//可以省略类名 5
System.out.println(id);//与上行一致 5
// System.out.println(age);//不能直接使用成员变量,必须跟随对象使用
StaticDemo01 staticDemo01=new StaticDemo01();
System.out.println(staticDemo01.age);//这个就可以使用了 10 //也可以采用对象.类变量 获取类变量 的值
System.out.println(staticDemo01.id);//5
//此行时,id=5,age=10;
staticDemo01.change(); System.out.println(id);//7
System.out.println(staticDemo01.age);//15
//局部变量的使用
String name="";
System.out.println(name);
}
//创建一个方法
public void change(){
id++;//6
age+=5;//11
StaticDemo01 staticDemo01=new StaticDemo01();
id++;//7
staticDemo01.age+=2;//11
System.out.println(id+"---"+staticDemo01.age);//7 12
System.out.println(id+"---"+this.age);//7 11
}
}

block块

分类

  1. {}定义在方法中 ->局部代码块|普通语句块 执行时间:方法调用时

  2. {}定义在类中方法外 ->构造块 执行时间:创建对象的时候

  3. static{}定义在类中方法外 ->静态 执行时间:类第一次加载的时候

其执行顺序如下 static -> main主方法 ->构造块 ->构造块

示例

public class BlockDemo01 {
static int a=45;
int b=30;
public static void main(String[] args) {
System.out.println("主方法");
BlockDemo01 b12=new BlockDemo01();
}
//类中方法外
{
System.out.println("构造块2");
System.out.println(a);
/*
* 创建对象分为三步(在堆中)
* 一是开辟空间,携带属性进入(如果没有值,则携带默认值,有值就是值本省)
* 在第一步的时候,已经携带属性b=3进入内存中,执行构造块
* 二是采用构造器初始化变量(第一次赋值)
* 三是返回内存中的位置
*/
System.out.println(b);
}
{
System.out.println("构造块3");
}
{
System.out.println("构造块4");
}
static{
System.out.println("静态块1");
System.err.println(a);
//由于静态是在对象创建之前,所以无法使用b
// System.out.println(b);
BlockDemo01 b12=new BlockDemo01();
System.out.println(b12.b);
}
static{
System.out.println("静态2");
}
static{
System.out.println("静态3");
}
}

封装javaBean

封装(Encapsulation)是面向对象方法的重要原则,就是把对象的属性和行为(或方法)结合为一个独立的整体,并尽可能隐藏对象的内部实现细节。

优点:

A:隐藏实现细节,提供公共的访问方式

B:提高代码的复用性

C:提高代码的安全性

注意:私有是封装,不能说封装是私有,封装不仅仅表示为私有。私有只是封装的一种体现,方法是封装的一种体现。

javaBean编码规则:

  1. javaBean 必须声明为 public class,这样才能够被外部所访问;

  2. 一个 JavaBean中至少存在一个无参构造方法

  3. 类中所有的属性都必须封装,即:使用 private 声明;

  4. 为封装的私有属性提供公共的 setter、getter 方法

Garbage Collection 垃圾回收机制

  1. 程序员无权调用垃圾回收器。

  2. 程序员可以通过 System.gc()。通知 GC 运行,但是 JAVA规范并不能保证立刻运行。

  3. finalize 方法,是 JAVA 提供给程序员用来释放对象或资源的方法,但是尽量少用

示例:

public class GCDemo01 {
public static void main(String[] args) {
//匿名对象 :没有名字的对象
//只能在当前行使用一次
GCDemo01 g=new GCDemo01();
System.gc(); //通知
System.out.println("123");
System.out.println("123");
System.out.println("123");
System.out.println("123"); } public void haha(){
System.out.println("哈哈哈哈,最近还是先吃火锅~~~");
} @Override
protected void finalize() throws Throwable {
System.out.println("over....");
}
}

package和import语句

package语句

为了便于管理大型软件系统中数目众多的类,解决类的命名冲突问题,Java 引入包(package)机制,提供类的多重类命名空间。

一般的命名为:公司域名倒写+功能名|模块名。例如:package com.shsxt.import06;

package 语句作为 Java 源文件的第一条语句,指明该文件中定义的类所在的包。(若缺省该语句,则指定为无名包)。

注意:不要定义与 jdk 相同的包,相同的类, 否则会引起很多你觉得莫名其妙的问题 。

如果一个类存在包名,则在使用该类时,必须使用全额限定名(简称全名或完整类名,com.shsxt.MyClass),编译器才能找到该类;也可以使用 import 在文件的开头引入要使用到的类。

import

  1. 类的上面进行导包:

  2. import 关键字 标识当前所使用的这个类的位置

  3. 这个包下的所有的类,如果有使用都可以引用

  4. 会降低编译效率,不会降低运行效率

  5. 静态导入: 只导入静态的内容

  6. 如果不使用import可以在使用的位置指明类的位置,包名+类名

注意:不要与jdk的 包名,类名出现相同情况

示例

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;
import java.util.*;
public class ImportDemo06 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
Random ran=new Random(); System.out.println(PI);
System.out.println(PI);
System.out.println(PI);
System.out.println(PI); System.out.println(sqrt(4));
}
}

extends继承

继承:子承父业

java 中使用 extends 关键字实现类的继承机制,语法规则:

<modifier> class <name> [extends <superclass>]{}

[ ]代表可有可有

作用

实现代码的复用,延续+扩展父类信息,子类可以扩展自己的内容 通过继承,子类自动拥有了基类的所有成员(成员变量和成员方法)。 Java 只支持单继承,不允许多继承:一个子类只能拥有一个基类,一个基类可以派生出多个子类

单继承的优点: 简单 单继承的缺点: 不便于后期维护

示例

public class ExtendsDemo01 {
public static void main(String[] args) {
Teacher th=new Teacher();
th.subject="java";
th.teach();
th.name="因为";
th.age=17; Student s=new Student();
s.hometown="杭州";
s.study();
s.name="马云";
s.age=50;
s.sleep(); }
}

//父类
class Person{
String name;
int age; public void sleep(){
System.out.println("休息");
}
}

//子类 教师类
class Teacher extends Person{ String subject; public Teacher() {
// TODO Auto-generated constructor stub
} public void teach(){
System.out.println("每天上课,边讲课边说rap");
} }

//学生类
class Student extends Person{
String hometown; public Student() {
// TODO Auto-generated constructor stub
}
public void study(){
System.out.println("学习敲代码,敲代码使我快乐~~~");
} }

修饰符

权限修饰符: 定义对象中内容的可访问范围

  本类 同包 不同包子类 不同包其他类
public Y Y Y Y
protected Y Y Y  
default(默认) Y Y    
private Y      

以上权限修饰符: 都只能修饰成员,不能修饰局部 能够修饰类的只有default|public

protected: 1.同包类,本类中直接使用 2.不同同包下的子类,必须通过继承关系才能使用

同类下

public class Modifier01 {
//分别定义不同的修饰符的变量
public String name="小王";
protected String mood="unhappy";
int age=520;
private double money=150;
//分别定义不同修饰符的方法
public void method01(){
System.out.println("public方法");
}
protected void method02(){
System.out.println("protected方法");
}
void method03(){
System.out.println("默认default");
}
private void method04(){
System.out.println("private方法");
} public static void main(String[] args) {
//在本类中,四种修饰符都可以使用
Modifier01 m=new Modifier01();
m.name="小王2";
m.mood="开心2";
m.age=521;
m.money=1563;
m.method01();
m.method02();
m.method03();
m.method04();
}
}

同包下其他类

package com.shsxt.modifier01;
public class Modifier02 {
public static void main(String[] args) {
//在本类中,四种修饰符都可以使用
Modifier01 m=new Modifier01();
m.name="小王2";
m.mood="开心2";
m.age=521;
// m.money=1563;
m.method01();
m.method02();
m.method03();
// m.method04();
}
}

不同包的子类

package TestModifier;
import com.shsxt.modifier01.Modifier01;
public class Modifier03 extends Modifier01 {
public static void main(String[] args) {
//在不同包子类中,四种修饰符可以使用的方法
Modifier01 m=new Modifier01();
m.name="小王2";
Modifier03 m1=new Modifier03();
System.out.println(m1.mood);
// m.mood="开心2";
// m.age=521;
// m.money=1563;
m.method01();
m1.method02();
// m.method03();
// m.method04();
}
}

不同包的其他类

package TestModifier;
import com.shsxt.modifier01.Modifier01;
public class Modifier04 {
public static void main(String[] args) {
//在本类中,四种修饰符都可以使用
Modifier01 m=new Modifier01();
m.name="小王2";
// m.mood="开心2";
// m.age=521;
// m.money=1563;
m.method01();
// m.method02();
// m.method03();
// m.method04();
}
}

this关键字、static关键字、block块、封装类以及继承、import、修饰符的初步了解的更多相关文章

  1. Java-静态关键字Static&静态代码块

    静态成员变量:(static修饰变量) 如果一个成员变量使用了static关键字,那么这个变量不再属于对象自己,而是属于所在的类.多个对象共享同一份数据. 静态方法:(static修饰方法) 一旦使用 ...

  2. static介绍、内部类、final、权限修饰符的作用范围

    static 关键字:(可用于修饰方法.变量)     static 特点:         static是静态修饰符,一般修饰成员变量.被static修饰的属于全局共享.被static修饰的成员属于 ...

  3. 总结 接口 final关键字 abstract关键字 static 关键字

    final关键字: * final 修饰的方法能被继承 不能被重写 * final修饰的类不能被继承 * final 修饰的变量(基本类型)不能被修改 * final 修饰的成员变量必须初始化 局部变 ...

  4. C/C++中static关键字的用法

    1.什么是static? static 是C/C++中很常用的修饰符,它被用来控制变量的存储方式和可见性. 1.1static的引入 我们知道在函数内部定义的变量,当程序执行到它的定义处时,编译器为它 ...

  5. abstract关键字及static关键字

    抽象关键字abstract 抽象类 在类前加上关键字abstract可以将此类变成抽象类.抽象类不允许通过new关键字实例化,但是可一通过其子类向上转型为其创建实例. 抽象类可以有抽象方法,也可以没有 ...

  6. C语言static关键字

    C语言static关键字 static关键字的作用,主要从在程序的生存周期.作用域和在代码段中的位置起作用. 全局变量 静态全局变量 局部变量 静态局部量 生存周期 程序运行到结束 程序运行到结束 函 ...

  7. 你真的了解JAVA中对象和类、this、super和static关键字吗

    作者:小牛呼噜噜 | https://xiaoniuhululu.com 计算机内功.JAVA底层.面试相关资料等更多精彩文章在公众号「小牛呼噜噜 」 目录 Java对象究竟是什么? 创建对象的过程 ...

  8. Block块

    block的标志:^ 特点: 1.可以保存代码 2.有返回值 3.有形参 4.调用方式和c语言一样 5.可以访问外部变量,但不能修改变量的值:如果使用__block关键字修饰的变量才可以. 1)创建 ...

  9. java基础语法(标识符 修饰符 关键字)

    标识符 用来表示类名,变量名,方法名,类型名,数组名,文件名的有效字符序列称为标识符.   1)只有字母(区分大小写),下划线,美元符号和数字组成,长度不受限制.注:字母包括英文26个字母 ,汉字,日 ...

随机推荐

  1. 利用reduce方法,对数组中的json对象去重

    数组中的json对象去重 var arr = [{ "name": "ZYTX", "age": "Y13xG_4wQnOWK1Q ...

  2. DataWorks2.0的“业务流程”与1.0的“工作流”的对比

    DatwWorks终于升级2.0了,心情万分激动之余,又有一丝担忧.因为,没法再创建新的旧版工作流了...新版抛弃了“工作流”这个概念,引入了“业务流程”和“解决方案”两个新的概念.于是,作为团队Le ...

  3. 经典单调栈最大子矩形——牛客多校第二场H

    题目是求次大子矩形,那么在求最大子矩形的时候维护M1,M2即可 转移M2时比较的过程要注意一下 #include<bits/stdc++.h> using namespace std; # ...

  4. 创建一个学生表student,默认的表空间为users,字段自定,同时为表的各个字段分别添加合适的约束,然后测试约束的验证状态。

    create table student(id number(4) constraint prim_key primary key,name varchar(8) not null,sex varch ...

  5. spring data jpa使用 (转:http://www.manongjc.com/article/25284.html#four_1_7)

    Jap相关的使用 时间:2018-12-18 本文章向大家介绍Jap相关的使用,主要包括Jap相关的使用使用实例.应用技巧.基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下. ...

  6. Restoring Road Network Floyd

    问题 C: Restoring Road Network 时间限制: 1 Sec  内存限制: 128 MB提交: 731  解决: 149[提交] [状态] [讨论版] [命题人:admin] 题目 ...

  7. eclipse新建maven项目和聚合项目

    1.new maven project :  next 2.勾选 create a simple project  :  next 3.Group Id:项目的包路径 如com.jiayou.zjl, ...

  8. java实现数字转中文大写

    package cn.aikang.ChineseC; import java.util.Scanner; /** * @Description: TODO(这里用一句话描述这个类的作用) * @Au ...

  9. JS对象随机数 random() 方法可返回介于 0 ~ 1(大于或等于 0 但小于 1 )之间的一个随机数。 注意:返回一个大于或等于 0但小于1的符号为正的数值

    随机数 random() random() 方法可返回介于 0 ~ 1(大于或等于 0 但小于 1 )之间的一个随机数. 语法: Math.random(); 注意:返回一个大于或等于 0 但小于 1 ...

  10. Linux queue.h之TAILQ队列分析

    转自 这两天想看看memcached的实现,所以先学习了libevent,使用起来还是比较简单的,其实是对select/poll/kqueue等的封装,学习libevent过程中又遇到了linux下队 ...