1.封装
概念：
将类中的属性隐藏在类的内部，使用private修饰，不让外部类直接访问，提供一对公开的getter、setter方法，getter方法用于获取属性值(读取)，setter方法用于设置属性值(写入)
封装的步骤：
1.属性私有
2.方法公开
封装的好处：
1.便于使用者正确使用系统，防止错误修改属性
2.降低了构建大型系统的风险
3.提高程序的可重用性
4.降低程序之间的耦合度
package com.qfedu.test1;
public class Student {
private String name;
private int age;
private double score;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
if(age > 0 && age <= 140) {
this.age = age;
}else {
System.out.println("年龄不合适，使用默认年龄");
this.age = 18;
}
}
public int getAge() {
return age;
}
public void setScore(double score) {
if(score >= 0 && score <= 100 ) {
this.score = score;
}else {
System.out.println("分数不合适，使用默认分数");
this.score = 60;
}
}
public double getScore() {
return score;
}
public void printStu() {
System.out.println("学生名字是" + name);
System.out.println("学生分数是" + this.getScore());
System.out.println("学生的年龄是" + getAge());
}
public static void main(String[] args) {
Student stu1 = new Student();
stu1.name = "赵四";
stu1.age = -20;
stu1.score = -50;
// 以上代码 在实际开发中不会将测试类和实体类写在一起
}
}
测试类
package com.qfedu.test1;
public class TestStudent {
public static void main(String[] args) {
Student stu1 = new Student();
stu1.setName("赵四");
stu1.setAge(-10);
stu1.setScore(-20);
stu1.printStu();
}
}
2.访问权限
类的访问权限：
public：本项目中都可以访问
默认不写：只在同一个包中可以访问
类成员的访问权限（属性、方法）：
private :本类中可以访问
默认不写：本类、同一个包中可以访问
protected：本类、同一包中、不同包的子类中可以访问
public：本类，同一个包中、不同包的子类中、任何地方
如果在同一个类中需要访问两个同名但是不同包的类，那么可以使用全部限定名(包名+类名)来访问
通过eclipse编辑器观察：
红色的方框表示私有private修饰的
蓝色的三角表示默认修饰的
黄色的圆角的方框是protected
绿色的圆点表示public修饰的
3.static关键字
Static 修饰变量，方法，代码块
修饰的变量为静态变量，类变量，用于实现数据共享，
或者在重复使用同一数据的情况下减少内存开销
定义方法：直接定义在类中
方法方式：本类中直接使用，其它类通过类名.访问
静态变量与实例变量的区别：
1，静态变量在内存中只有一份拷贝
2，实例变量是多份拷贝，多个实例之间，互不影响之间没有关系
3.1 static修饰属性
适用场景：
修饰属性：表示此属性属于类级别的，不依托于对象而存在，将被所有的对象共享
类加载的过程：
1.当我们第一次访问一个类时，JVM将在方法区加载此类的class文件，并且只加载一次
2.在堆中开辟一块空间，并且所有的实例变量将有默认值
3.将堆中的地址赋值给栈中的引用
方法区：
方法区是JVM提供的一个规范，javaJVM的名字hotspot
JDK8之前java中的方法区叫作永久代
JDK8之后改名为元数据
方法区和堆：
方法区和堆共享内存空间，但是方法区是静态分配内存的，我们所使用static修饰的属性，方法，代码块都是只要类被加载，就存在的，堆是随着程序的执行动态分配内存的
举例：我们的姓氏是出生就存在的，相当于静态的，我们的性格是随着成长生成的，相当于动态的。
栈：先进后出
堆：先进先出
static修饰的变量都是共享的，存在于方法区，（饮水机取水，最后一个取完剩多少，这个量就是多少。）
3.2static修饰方法
static修饰的方法称之为静态方法，
访问方式：本类中直接访问，其他类可以直接通过类名访问，不需要创建对象
main方法是常用的静态方法，是类级别的方法
静态方法和实例方法的不同
1，实例方法可以直接访问静态方法，反之不行，需要先new对象
2，静态方法不能直接访问，需要先new对象
静态方法、代码块中中能不能直接访问非静态的属性和方法？
不能，必须要先创建对象
静态方法、代码块中能不能直接访问静态的属性和方法？
可以，静态与静态之间互相可以直接访问
package com.qfedu.test5;
public class TestStaticMethod {
public static void m1() {
System.out.println("静态方法1");
}
public static void m2() {
System.out.println("静态方法2");
}
public void m3() {
System.out.println("普通方法3");
}
public static void main(String[] args) {
m1();
TestStaticMethod tsm = new TestStaticMethod();
tsm.m3();
}
}
3.3 static修饰代码块
被static修饰的代码块，称之为静态代码块，当JVM加载类的时候，就执行，多个静态代码块按照顺序执行，并且只执行一次，因为类只加载一次
定义方法：类内部 static()
作用：可以实现一些参数的初始化，连接数据库等前置操作…
适用场景：当我们需要做一些前置的操作，比如连接数据库，或者初始化数据
普通代码块：直接一对大括号，只要对象创建就会被执行
package com.qfedu.test5;
public class TestStaticCode {
static int num = 20;
String name;
static {
System.out.println("静态代码块1");
}
static {
// System.out.println(name);
System.out.println(num);
System.out.println("静态代码块2");
}
public void m1(){
System.out.println(num);
}
{
System.out.println(num);
System.out.println("普通代码块1============");
}
{
System.out.println("普通代码块2=============");
}
public static void main(String[] args) {
// 静态代码块 当我们的类被加载 就会被执行 多个静态代码块按照顺序执行 并且只执行一次
// 用于一些前置的操作 或者 数据的初始化操作
// TestStaticCode tsc1 = new TestStaticCode();
//
// TestStaticCode tsc2 = new TestStaticCode();
//
// TestStaticCode tsc3 = new TestStaticCode();
System.out.println(TestStaticCode.num);
}
}
4.0继承
继承：跟我们生活中的继承类似
作用:用于通过继承实现代码的重用
如何实现：通过extends关键字
在哪实现：当我们多个类有共同的特征，这时候我们可以将这些共同特征再次抽取一个类
这个类称为父类
实现的 优点：代码重用
继承包括哪些内容：
本包中：使用默认 或者 以上范围 修饰符修饰的方法和属性
不同包中：使用protected 或者
5super关键字
作用 调用父类的属性 方法 构造方法
属性： 直接super加点访问即可，需要满足继承的条件
方法： 直接super加点访问即可，也需要满足继承的条件
构造方法： 直接通过super()使用，只能在构造方法中， 并且只能在第一句，
一个子类的构造方法中只能使用一次父类的构造方法。
扫一扫
439
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
