点击蓝字｜关注我们
01
类和对象
什么是类和对象
1. 对象的概念
客观存在的事物
2. 什么是面向对象
面向对象的方法主要是把事物给对象化，包括其属性和行为
3. 类
类是模子，确定对象将会拥有的特征(属性)和行为(方法)
类是对象的类型，是具有相同属性和方法的一组对象的集合，即一个类对应多个对象
4. 什么是对象的属性
属性是对象具有的各种特征，每个对象的每个属性都拥有特定的值。
5. 什么是对象的方法
方法是对象执行的操作，即对象能做什么
6. 类与对象的关系/区别
类是抽象的概念，仅仅是模板，比如“手机”；
对象是一个能够看得到、摸得着的具体实体
| 类 | “手机”类 |
|---|---|
| 特征 (属性) | 屏幕、cpu、内存 |
| 行为 (方法) | 打电话、发短信 |
“手机”类对应的对象为具体的某一款手机，如iphone5、三星note
定义java中的类
所有java程序都以类class为组织单元
类是模子，确定对象将会拥有的特征(属性)和行为(方法)
类由属性和方法组成。
1. 定义类名
2. 编写类的属性
3. 编写类的方法
public class 类名{ //定义属性部分(成员变量) 属性1的类型 属性1；属性2的类型 属性2; ... 属性n的类型 属性n；//定义方法部分 方法1; 方法2; ... 方法m; }类名首字母大写
例如：
//1.定义一个类 public class Telephone { //2.属性(成员变量)有什么 float screen; float cpu; float mem; //3.方法 能干什么 void call() { System.out.println("Telephone有打电话的功能！"); } void sendMessage() { System.out.println("Telephone有发短信的功能！"); } }使用对象的步骤
1.创建对象
类名 对象名 = new 类名();
Telephone phone = new Telephone();//对类进行实例化2.使用对象
引用对象的属性：对象名.属性
引用对象的方法：对象名.方法名()
属性即实例变量
phone.screen = 5;//给screen属性赋值为5phone.sendMessage();//调用sendMessage()方法例子：Telephone.java
//1.定义一个类public class Telephone { //2.属性(成员变量)有什么 float screen; float cpu; float mem; //3.方法 能干什么 void call() { System.out.println("Telephone有打电话的功能！"); } void phoneDetail() { System.out.println("screen:"+screen+" cpu:"+cpu+" mem:"+mem); }}InitialTelephone.java(在同一个包下再创建一个class，勾选上main)
public class InitialTelephone { public static void main(String[] args) { // TODO Auto-generated method stub Telephone phone = new Telephone(); //给实例变量赋值 phone.screen = 5.0f; phone.cpu = 1.4f; phone.mem = 2.0f; //调用方法 phone.phoneDetail(); }}
成员变量和局部变量
1. 成员变量在类中定义，用来描述对象将要有什么。
2. 局部变量在类的方法中定义，在方法中临时保存数据。
3. 区别
作用域不同：
局部变量作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的，类中的所有方法都可以共享成员变量
初始值不同：java会给成员变量一个初始值；
java不会给局部变量赋予初始值；
同名问题：同一个方法中，不允许有同名的局部变量，不同方法中，可以有同名局部变量；就近原则 两类变量同名时，局部变量具有更高的优先级！
构造方法
实际为：new 构造方法，创建一个新的对象，对象类型即为该类，如Telephone phone = new Telephone();使用的是new Telephone()创建的对象phone，对象phone的类型为Telephone，Telephone()为构造方法
构造方法是定义在java类中的一个用来初始化对象的方法；
构造方法与类同名，没有返回值，有无参数均可。
当没有指定构造方法时，系统会自动添加无参的构造方法；
当有指定构造函数时，无论是有参、无参的构造方法，系统都不会自动添加无参的构造方法；
带参的构造函数的目的就是为了初始化对象成员变量的值；
Telephone.java
public class Telephone { float screen; float cpu; float mem; public Telephone() { System.out.println("无参构造函数已执行！"); } public Telephone(float newScreen, float newCpu, float newMem) { screen = newScreen; cpu = newCpu; mem = newMem; System.out.println("有参构造函数已执行！"); }}InitialTelephone.java
public class InitialTelephone { public static void main(String[] args) { // TODO Auto-generated method stub //无参构造函数创建对象 Telephone phone1 = new Telephone(); //有参构造函数创建对象，并赋初值 Telephone phone2 = new Telephone(1.2f,1.3f,5.6f); }}构造方法也可以重载，同普通方法重载相同；
构造方法不但可以给对象属性赋值，还可以保证给对象属性赋一个合理的值，可以加判断，如：
public Telephone(float newScreen, float newCpu, float newMem) { if(newScreen < 3.5) { screen = 3.5f; System.out.println("您输入的参数有问题！"); }else { screen = newScreen; } cpu = newCpu; mem = newMem; System.out.println("有参构造函数已执行！"); System.out.println("screen:"+screen+" cpu:"+cpu+" mem:"+mem); }
静态变量
使用static修饰的成员称为静态成员或类成员，其属于整个类所有，并非某个对象，即被类的所有对象共享，可以使用类名直接访问(推荐)，也可以使用对象名访问；
static可以以修饰变量、方法和代码块。
public class HelloWorld { static String hobby = "Java"; public static void main(String[] args) { System.out.println("通过类名访问："+HelloWorld.hobby);//Java HelloWorld hello = new HelloWorld(); System.out.println("通过对象名访问："+hello.hobby);//Java hello.hobby = "C++"; System.out.println("通过类名访问："+HelloWorld.hobby);//C++ HelloWorld.hobby = "123"; System.out.println("通过对象名访问："+hello.hobby);//123 }}
静态方法
public class HelloWorld { public static void print() { System.out.println("welcome!"); } public static void main(String[] args) { //直接通过类名调用 HelloWorld.print(); //创建对象，通过对象调用 HelloWorld hello = new HelloWorld(); hello.print(); }}静态方法可以直接调用同类中的静态成员，但是不能直接调用非静态成员，如：
普通成员方法中，可以直接访问同类的非静态变量和静态变量，如
静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法，如：
静态初始化块
类中静态语句块仅在类加载时被执行一次
static{//...}
初始化块：
public class HelloWorld{ String name;//定义一个成员变量 //通过初始化块为成员变量赋值 { name = "imooc"; }}public class HelloWorld { int num1; int num2; static int num3; public HelloWorld() { num1 = 91; System.out.println("通过构造方法为变量num1赋值"); } { num2 = 74; System.out.println("通过初始化块为变量num2赋值"); } static { num3 = 83; System.out.println("通过静态初始化块为静态变量num3赋值"); } public static void main(String[] args) { HelloWorld hello = new HelloWorld(); System.out.println("num1 = "+hello.num1); System.out.println("num2 = "+hello.num2); System.out.println("num3 = "+num3); HelloWorld hello2 = new HelloWorld(); }/*结果：通过静态初始化块为静态变量num3赋值 ------(静态初始化块最先被执行)通过初始化块为变量num2赋值------(然后执行普通初始化块)通过构造方法为变量num1赋值------(最后执行构造方法)num1 = 91num2 = 74num3 = 83通过初始化块为变量num2赋值通过构造方法为变量num1赋值------(静态初始化块只在类加载时执行一次，故创建hello2对象时，只执行普通初始化块和构造方法)*/02
面向对象三大特性(1)---封装
封装的概念
将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
编程规范：标准的面向对象程序，不能直接操作类的属性信息，只能通过类的方法来间接操作 set/get方法
使用封装的好处
只能通过规定的方法访问数据
隐藏类的实例细节，方便修改和实现
封装的实现步骤
修改属性的可见性，添加修饰符private
创建getter/setter方法，用于属性的读写
在getter/setter方法中加入属性控制语句，对属性的合法性进行判断
例：
Telephone.java
//类的封装public class Telephone { private float screen;//步骤1 private float cpu; private float mem; public float getScreen() {//步骤2 return screen; } public void setScreen(float newScreen) {//步骤2 if(newScreen<1.5f) {//步骤3 screen = 1.5f; }else { screen = newScreen; } } }InitialTelephone.java
public class InitialTelephone { public static void main(String[] args) { // TODO Auto-generated method stub Telephone phone = new Telephone(); phone.setScreen(1.6f);//通过类的方法来操作类的属性 System.out.println(phone.getScreen()); }}包的作用
管理java文件
解决同名文件冲突与文件夹的功能类似
定义包
package 包名
必须放在java源程序的第一行，包名之间用.隔开来区分层次
如：音乐类--MyClassMusic
-musiccom.imooc.music.MyClassMusic
-moviecom.imooc.music.MyClassMusic
系统中的包
java.(功能).(类)
java.lang.(类) 包含java语言基础的类
java.util.(类) 包含java语言中各种工具类
java.io.(类) 包含输入、输出相关功能的类
包的使用
通过import关键字，使用其他文件中的类
import com.imooc.Telephone
import com.imooc.secondTelephone
可以通过导入不同的包来区分两个Telephone类
java中包的命名规范为：全是小写字母拼写
可以导入某个包下的所有文件、某个具体子包下的所有文件
import com.imooc.*
import com.imooc.music.*
访问修饰符
可以修饰属性和方法的访问范围
| 访问修饰符 | 本类 | 同包 | 子类 | 其他 |
|---|---|---|---|---|
| private | √ | |||
| 默认 | √ | √ | ||
| protected | √ | √ | √ | |
| public | √ | √ | √ | √ |
this关键字
this代表当前对象，封装对象属性的时候经常会使用this关键字
this.属性 操作当前对象的属性
this.方法 操作当前对象的方法通过eclipse--source--generate getter and setter来自动生成get set方法
//类的封装public class Telephone { private float screen;//步骤1 private float cpu; private float mem; public void sendMsg() { System.out.println("send message"); } public float getCpu() { return cpu; } public void setCpu(float cpu) { this.cpu = cpu;//属性前加this关键字 this.sendMsg();//方法前加this，直接调用该方法 } public float getMem() { return mem; } public void setMem(float mem) { this.mem = mem; } public float getScreen() { return screen; } public void setScreen(float screen) { this.screen = screen; } }内部类(Inner Class)
定义在另外一个类里边的类，与之对应，包含内部类的类称为外部类。
内部类的作用
内部类提供了更好的封装方法，可以把内部类隐藏在外部类里边，不允许同一个包中的其他类访问该类
内部类的方法可以直接访问外部类的所有数据，包括私有数据
内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
内部类的种类
成员内部类
静态内部类
方法内部类
匿名内部类只能内部类对象调用内部类方法，外部类对象调用外部类方法？
public class HelloWorld { // 内部类Inner，类Inner在类HelloWorld的内部 public class Inner { // 内部类的方法 public void show() { System.out.println("内部类方法！"); } } public void print() { System.out.println("外部类方法！"); } public static void main(String[] args) { // 创建外部类对象 HelloWorld hello = new HelloWorld(); // 调用外部类对象的方法 hello.print(); // 创建内部类对象 Inner i = hello.new Inner(); // 调用内部类对象的方法 i.show();//只有内部类对象才可以调用内部类方法 }}成员内部类
public class Outer { private int a = 99; int b = 1; public class Inner{//成员内部类，即普通内部类 int b = 2; public void test() { System.out.println("访问外部类中的a："+a); System.out.println("访问外部类中的b："+Outer.this.b); System.out.println("访问内部类中的b："+b); } } public static void main(String[] args) { Outer o = new Outer(); Inner i = o.new Inner(); i.test(); }}外部类不能直接访问内部类的成员方法
静态内部类
静态内部类不能直接访问外部类的非静态成员，但可以通过new外部类().成员的方式访问。
public class Outer { private int a = 99; static int b = 1; public static class Inner{ int b = 2; static int c = 4; public void test() { //静态内部类访问外部类非静态成员 new 外部类名(). System.out.println("外部类中的a："+new Outer().a); //静态内部类访问外部类静态成员 System.out.println("外部类中的b："+Outer.b); //静态内部类访内部类非静态成员 System.out.println("内部类中的b："+b); //静态内部类访内部类静态成员 System.out.println("内部类中的c："+c); } } public static void main(String[] args) { Inner i = new Inner();//不需要外部类对象，可以直接创建内部类对象 i.test(); }}方法内部类
定义在外部类的方法中的类称之为方法内部类，方法内部类只在该方法的内部可见，即只在该方法内可以使用
public class Outer { public void show() { final int a = 25; int b = 13; //方法内部类不能在外部类的方法以外使用，故不能使用访问控制符和static修饰符 class Inner{ int c = 2; public void print() { System.out.println("访问外部类的方法中的常量a：" + a); System.out.println("访问外部类的方法中的变量b：" + b); System.out.println("访问内部类中的变量c：" + c); } } Inner i = new Inner(); i.print(); } public static void main(String[] args) { Outer o = new Outer(); o.show(); }}
点赞关注回复“JavaSE”或者点击粉丝福利领取学习资料，简单清晰无套路，不给小编秃头！！
扫一扫
330
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
