第六章 面向对象，封装等

类 对象
类：是一个抽象的概念：模板。比如：人，学生。
对象：是一个看得见 ，摸得着的实体。
组成：属性（静态特征）、方法（动态行为：功能的体现）
类和对象之间的关系
对象是类的一个实例(一个类可以创建多个对象)如:
Student zhangS=new Stduent() ;
Student liSi=new Stduent() ;
如何创建使用对象
通过 new 关键字来创建,通过操作符来进行调用里面的属性还有方法
如:
Student zhangS=new Stduent() ;
zhangS.name=“张三”;
zhangS.age=19;
zhangS.show();
创建对象和调用
1.创建对象
语法格式：

类名 对象名 = new 类名（）；

new是关键字

左半边的类名为对象的数据类型

右边的 类名（） 称为类的构造方法

2.调用属性
语法格式：

对象名.属性 //引用对象的属性

3.调用方法
语法格式：

对象名.方法名（） //引用对象的方法

实现具体的功能
如：public void show(){
}
语法：
访问修饰符 返回值类型 方法名（[参数]）{ }
无惨方法
//无返回值，无参：
public void show(){
System.out.println(“姓名：”+name);
}
//有返回值，无参
public String show(){
return “abc”;
}
有参方法
//一个基本参数
public void add(int num){ num++;
}
//多个基本参数
public void sum(int num,int num1){
int sum=num+num1;
}
//数组参数
public void sort(int[] array) {
Arrays.sort(array);
}
//对象参数
public void addStudent(Stduent stu){ System.out.println(stu.name);
}
//对象数组参数
public void update(Stuent[] stus){
for(Student stu:stus){
if(stu.score<60){
stu.score+=2;
}
}
}
无返回值的方法
//用void 修饰
public void show(){
System.out.println(“姓名：”+name);
}
有返回值的方法
若方法有返回值,必须使用return语句进行返回;并且返回值只能有一个。返回值的类型必须和你定义的类型一致。
public int sum(){
return 1;
}
public String show(String name){
return “—”;
}
public Stduent select(){
return new Student();
}
public int[] test(){
int arr[]={1,2};
return arr;
}
构造方法
作用:实例化对象
语法:
访问修饰符 方法名( ){//方法名与类名一致
}
//默认无参构造方法
如果自己修改,添加了新的构造方法,默认就不存在了。
public Student(){
}
public Student(){
name="";
age=19;
}
public Student(String name,int age){
this.name=name;
this.age=age;
}
方法的重载
同一类中，方法名相同，参数列表不同一组方法，称为方法的重载。返回值类型，访问修饰符无关。
//构造方法的重载
public Student(){
}
public Student(){
//this();
name="";
age=19;
}
public Student(String name,int age){
this.name=name;
this.age=age;
}
//方法的重载
public void add(int num,int num1){
int sum=num+num1;
}
public void add(double num1,double temp,double num2){
double sum=num1+temp+num2;
}
this关键字
this代表当前对象
作用：
可以区分成员变量和局部变量
调用构造方法（必须写在第一行）
this.方法名（ ）；
局部变量与成员变量
位置：
局部变量定义方法内
成员变量定义在类里
作用范围：
局部变量（当前方法）
成员变量（当前类，其他类）
注意：
局部变量（无默认值，要想直接使用，需要初始化操作）
成员变量（有默认值）
同一个方法中不允许有两个同名的变量
不同的方法中有同名的变量
封装
　　　　访问修饰符
static静态(在内存只有一份)
变量(静态变量,类变量)
类名.变量名称
直接使用
实例.(点)变量名(new 对象方式)
public class StaticTest {
static int num=0;//静态变量
static final String address=“运城”;//常量
public static void main(String[] args) {
StaticTest.num++;//类名.变量名
num++;//直接使用
StaticTest st1=new StaticTest();
st1.num++;//实例.变量名
System.out.println(StaticTest.num);
}
}
方法(类方法)
类名.方法名
方法名();
实例.(点)方法名;
public class StaticTest {
public static void show() {//静态方法
}
static final String address=“运城”;//常量
public static void main(String[] args) {
StaticTest.show();//类名.方法名
show();//直接使用
StaticTest st1=new StaticTest();
st1.show();//实例.方法名();
}
}
代码块
静态代码块,当java虚拟机加载类,就会执行该代码块多个静态代码块依次执行
public class StaticTest {
static int num = 100;// 静态的变量
static {//静态代码块
num += 100;
System.out.println(num);
}static {
num += 100;
System.out.println(num);
}
}
区别
静态:
在内存只有一份
被static修饰的变量
类的内部, 可以在任何方法内直接访问静态变量
其他类中, 可以直接通过类名访问
非静态
a.没有被static修饰的变量
b.每创建一个实例,就会为实例变量分配一次内存,实例变量在内存中有多个拷贝,互不影响
static方法注意事项
静态方法中不能使用this和super
不能直接访问所属类的实例变量和实例方法
可直接访问类的静态变量和静态方法

封装
一.概念
封装的实质就是将类的状态信息隐藏在类的内部，不允许外部程序直接访问，

而是通过使用该类提供的方法来实现对隐藏信息的操作和访问。

二.步骤
1.修改属性的可见性
将类中的属性的访问修饰符修改为private

2.设置getter/setter方法
可以手动设置，也可以使用 Ctrl +Shift+S快捷键由系统添加

3.设置属性的存取限制
可以在set方法中进一步利用条件判断语句进行赋值限制。

 包

1.概述
Java中的包机制也是封装的一种形式
包实际上是一种访问控制机制，通过包来限制和制约类之间的访问关系
包可以防止命名冲突
包类似于文件夹，易于找到和使用相应的类文件
包允许在更广的范围内保护类、数据和方法。
2.定义
语法格式：

package 包名；

package是关键字
包的声明必须是java源文件中的第一条非注释性语句，而且一个源文件只能有一个包声明语句
包名前缀通常使用组织网络域名的逆序。
包名的后续依不同机构各自内部的规范不同而不同，可能以特定目录名的组成来区分部门、项目、机器或注册名
一般都用com,edu,gov,net及org来作为域名创建包
3.使用
声明：声明当前类所在的包

导入（import）：声明在当前类中要使用到其他类所在的包　快键键ctrl+shift+o

本文地址：https://blog.csdn.net/wuzhangxiong123/article/details/107348268