1、封装
封装的意义:保护或防止代码( 数据 )被我们无意中破坏了,
为避免逻辑错误,建议对所有属性进行封装,
并为其提供 getter、setter 进行设置和取得操作
get 、 set 的封装列子
public class demo10 {
public static void main(String[] args) {
person10 p = new person10();
p.name = “张三”;
p.setAge(99);
p.say();
}
}
class person10{
private int age ;
String name;
void setAge(int age2){
if ( age2<10 || age2>150){
System.out.println("年龄不合理,自动设置为1");
age = 1;
}else {
age = age2;
}
}
int getAge() {
return age;
}
void say(){
System.out.println("自我介绍:姓名:"+name+",年龄:"+age);
}
}
2、this 关键字 指的是当前对象
①②③④⑤⑥⑦⑧⑨⑩
① 调用类中的属性
② 调用类中的方法 和 构造方法
③ 在一个构造方法中调用另一个构造方法时
调用的代码 必须写在构造方法的第一行
原因:this 关键字调用的对象时在堆内存创建对象时( 即对象在堆内存初始化 )还没有完毕,
要等待对象在堆内存初始化完毕,然后再执行其他的逻辑,否则会报错
// 构造器是用于参数传入传出的,其实就是一个构造方法,
要传参数的话就肯定要有构造器
public class thisKeyword {
public static void main(String[] args) {
person11 p1 = new person11("张三",18);
person11 p2 = new person11("李四" ,18);
p1.say();
p2.say();
person11 p3 = new person11();
p3.say();
}
}
class person11{
private String name;
private int age;
public person11() { //无参构造器,与有参构造器可以相互调用
this("默认的年龄",1); // 这里调用有参构造器
System.out.println("这里逻辑的执行要在 “ this(\"默认的年龄\",1);” 这句话的下面,"+ "\n"+
"因为构造器还没初始化设置完毕");
}
public person11(String name, int age) { // 有参构造器,与无参构造器可以相互调用
this.name = name;
this.age = age;
}
void say(){
System.out.println("自我介绍:姓名:"+this.name+",年龄:"+this.age);
}
}
3、静态 static
静态的属性存放在 方法区 中的内存地址
类加载之后其内存就是加载在 方法区 中
静态的属性( 加了 static 的属性 )之后的属性直接用类名加点访问就可以了
一个类里面对象可以有很多个,但一个大类只能有一个
静态修饰的方法,被调用时,有可能对象还未创建
对象已经创建,说明类已经加载,又说明方法已经被调用
public class staticClass {
public static void main(String[] args) {
emp e1 = new emp("张三","北京");
emp e2 = new emp("李四","北京");
emp e3 = new emp("王五","北京");
emp e4 = new emp("赵六","北京");
// 地址迁移到天津
/*e1.setRegion("天津");
e2.setRegion("天津");
e3.setRegion("天津");
e4.setRegion("天津");*/
emp.region = "天津"; // 属性加了静态后,直接用类名调用静态属性就可以了
e1.say();
e2.say();
e3.say();
e4.say();
}
}
class emp{
private String name;
static String region;
// 有了有参、无参的构造器,就随便你传入传出单参数、双参数,都可以了
public emp(String name, String region) { // 构造器是用于参数传入传出的,其实就是一个构造方法
this.name = name;
this.region = region;
}
public emp() { // 构造器是用于参数传入传出的,其实就是一个构造方法
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getRegion() {
return region;
}
public void setRegion(String region) {
this.region = region;
}
void say(){
System.out.println("姓名:"+name+",员工所在地:"+region);
}
}
静态方法和非静态方法的调用区别
public class staticClass2 {
public static void main(String[] args) {
static1.say();
/*static1.say2();*/ // 非静态方法调用时不能直接用 类名加点 的方法调用
static1 s = new static1();
s.say2();
}
}
//静态修饰的方法,被调用时,有可能对象还未创建
class static1{
static void say(){
System.out.println(“锄禾日当午”);
}
void say2(){
System.out.println("从这里开始是非静态调用:\n 汗滴禾下土");
say(); // 非静态方法可以调用静态方法,静态方法不能调用非静态方法,
// 因为静态方法比非静态非法执行快很多,很多时候类加载时,非静态方法还没有创建对象呢!
}
}
static 静态,用于修饰成员变量、成员方法、代码块、内部类
static 主要作用在与创建独立与具体对象的域变量或者方法( 被static 关键字修饰的
方法或者变量不需要依赖对象进行访问,只要类被加载了,就可以通过类名
去进行访问。并且不会因为对象的多次创建而在内存中建立多份数据 )
static静态 重点 :
①静态成员 在类加载时 加载并初始化
②无论一个类存在多少对象,静态的属性,永远在内存中只有一份( 可以理解为所有对象公用)
③在访问时 : 静态不可以访问非静态,非静态可以访问静态
// 静态方法不能调用非静态方法,非静态方法可以调用静态方法,
// 因为静态方法比非静态非法执行快很多,
// 很多时候类加载时,非静态方法还没有创建对象呢!
4、包
代码中写类的全名称时不用导包
如 : Java . util . Scanner input = new Java . util . Scanner ( System . in ) ;
String 这个代码不用导包 Java . lang 包里面,这个包里很多都是常用的代码
5、权限修饰符 : public protected default private
default 是默认修饰符,什么都不写也是默认修饰符的意思
只有是 public 修饰的包才可以访问
private 是封装到了极致,只在一个类里进行封装成员属性、成员变量、成员方法等
6、普通代码块就是顺序执行的代码块
构造代码块 : 在类中编写的代码块成员,如 { } ,后面不用加分号
构造代码块,随着对象的每次创建,执行一次,
并执行在构造器(构造方法)之前,而构造器不一定执行,
因为构造器可能有重载,可能有一参的、两参的、多参的、无参的,
当构造器的其他参数没有执行是,构造器就不会被调用,即不会被执行
构造代码块无论通过什么构造方法创建对象,构造代码块都会执行,也可以写多个构造代码块
构造代码块区别于构造方的是 : 无论用户调用哪一个构造方法来创建对象,构造代码块都必然执行
静态代码块 就是在构造代码块前加上 static , 如 static { } ,后面不用加分号
静态代码块,随着类的加载( 第一次使用 ),静态代码块执行,
因为类只加载一次,所以静态代码块只执行一次
代码块的执行顺序 : 静态代码块 > 构造代码块 > 构造方法
7、main方法 是 JVM ( Java Virtual Machine ) 执行程序的入口
main方法中 String [ ] args 是字符串数组,接收参数用的