访问权限修饰符 public > protected > (default) > private 本类中 同包下的不同类 不同包下的子类 不同包下的其他类 public公开的 OK OK OK OK protected受保护的 OK OK OK (default)默认的 OK OK private私有的 OK 1.public修饰符，可以修饰类、成员变量、成员方法 2.protected修饰符，不可以修饰类；可以修饰成员变量、成员方法 3.(default)修饰符，直接不写的，可以修饰类、成员变量、成员方法 4.private修饰符，不可以修饰类；可以修饰成员变量、成员方法
第1章 面向对象基础
面向对象思想概述：
当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。
面向对象思想特点：
面向对象是基于面向过程的编程思想；
面向过程：强调的是每一个功能的步骤；
面向对象：强调的是对象，然后由对象去调用功能；
A：是一种更符合我们思考习惯的思想
B：可以将复杂的事情简单化
C：将我们从执行者变成了指挥者
角色发生了转换
类与对象的关系：
我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。
我们如何表示一个现实世界事物呢？
A：属性 就是该事物的描述信息
B：行为 就是该事物能够做什么
我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
类：是一组相关的属性和行为的集合
对象：是该类事物的具体体现
第2章 类和对象
2.1 类的定义
2.1.1 现实世界的事物
类是用来描述现实世界的事物的。
事物：
属性 事物的描述信息
行为 事物能做什么
2.1.2 Java中用class描述事物也是如此
成员变量 就是事物的属性
成员方法 就是事物的行为
/**
* ====》 现实世界
* 人类
* 属性（描述事物的信息） 行为（描述事物的功能）
* 对象A 姓名张三、年龄22、性别男 吃饭、睡觉
* 对象B 姓名李四、年龄18、性别女 吃饭、睡觉
*
* ====》 Java世界必须要与现实世界一一对应的
* Person类 语法：public class 类名{ }
* 属性：
* 1.例如：String name、int age、char sex
* 2.语法：数据类型 属性名;
* 3.又称为成员变量
* 行为：
* 1.例如：public void eat(){ } 、public void sleep(){ }
* 2.语法：public void/数据类型 方法名(形参){}
* 3.又称为成员方法
*
* 创建对象
* 语法：类名 对象名 = new 构造方法(); //构造方法本身与类名同名
* 使用对象中的属性
* 语法：对象名.属性名 = 值;
* 使用对象中的方法
* 语法：对象名.方法名();
*
* 总结：
* 1.分析时先有对象->属性->行为->类，编写代码时类->属性->行为->对象
* 2.类是对象的模板
* 3.面向对象的思想
*/2.1.3 定义类其实就是定义类的成员(成员变量和成员方法)
1:成员变量 和以前定义变量是一样的。
只不过位置发生了改变：在类中，方法外。
初始化值：不需要给初始化值。
2:成员方法 和以前定义方法是一样的。
只不过把static去掉，后续再详细讲解static的作用。
2.2 类与对象的案例
2.2.1 学生类
2.2.1.1 如何定义
按照事物到类的过程一步步分析
/*
* 学生类：
* 成员变量：姓名，年龄
* 成员方法：学习，吃饭
*/
public class Student {
//成员变量
/**
* @Fields name : 姓名
*/
String name;
/**
* @Fields age : 年龄
*/
int age;
//成员方法
/**
* @Title: study
* @Description: 学习的方法
*/
public void study(){
System.out.println("好好学习，天天向上！");
}
/**
* @Title: eat
* @Description: 吃饭的方法
*/
public void eat(){
System.out.println("学习饿了，要吃饭。");
}
}2.2.1.3 如何使用
使用一个类，其实就是使用该类的成员。(成员变量和成员方法)
而我们要想使用一个类的成员，就必须首先拥有该类的对象。
1.我们该如何拥有一个类的对象呢？
创建对象就可以了。
2.我们如何创建对象呢？
创建对象的格式： 类名 对象名 = new 构造方法();
3.对象如何访问成员呢？
成员变量：对象名.成员变量
成员方法：对象名.成员方法()
public class StudentDemo {
public static void main(String[] args) {
//格式：类名 对象名=new 类名();
Student s=new Student();
System.out.println("s:"+s);//s:com.igeek_02.Student@feb48
//直接输出成员变量值
System.out.println("姓名："+s.name);//null
System.out.println("年龄："+s.age);//0
System.out.println("---------------");
//给成员变量赋值
s.name="吴京";
s.age=35;
//再次输出成员变量的值
System.out.println("姓名："+s.name);//吴京
System.out.println("年龄："+s.age);//35
System.out.println("---------------");
//调用成员方法
s.study();
s.eat();
}
}案例手机类：
/**
* @ClassName: Phone
* @Description: 手机类
*
* 手机类：
* 成员变量：品牌、价格、颜色...
* 成员方法：打电话、发短信...
*/
public class Phone {
/**
* @Fields brand : 品牌
*/
String brand;
/**
* @Fields price : 价格
*/
int price;
/**
* @Fields color : 颜色
*/
String color;
/**
* @Title: call
* @Description: 打电话
* @param name
*/
public void call(String name){
System.out.println("给"+name+"打电话");
}
/**
* @Title: sendMessage
* @Description: 发短信
*/
public void sendMessage(){
System.out.println("群发短信");
}
}手机类的使用：
/**
* @ClassName: PhoneDemo
* @Description: 手机类的测试类
*/
public class PhoneDemo {
public static void main(String[] args) {
//创建对象
Phone p=new Phone();
//输出成员变量
System.out.println("品牌："+p.brand);//null
System.out.println("价格："+p.price);//0
System.out.println("颜色："+p.color);//null
System.out.println("-------------------");
//给成员变量赋值
p.brand="华为Mate10";
p.price=3999;
p.color="黑色";
//再次输出成员变量
System.out.println("品牌："+p.brand);//华为Mate10
System.out.println("价格："+p.price);//3999
System.out.println("颜色："+p.color);//黑色
System.out.println("-------------------");
//调用成员方法
p.call("吴京");
p.sendMessage();
}
}2.3 对象内存图
2.4 成员变量和局部变量的区别
2.4.1 在类中的位置不同
成员变量： 类中方法外
局部变量： 方法内或者方法声明上(形式参数)
2.4.2 在内存中的位置不同
成员变量： 堆内存
局部变量： 栈内存
2.4.3 生命周期不同
成员变量： 随着对象的存在而存在，随着对象的消失而消失
局部变量： 随着方法的调用而存在，随着方法的调用完毕而消失
2.4.4 初始化值不同
成员变量： 有默认的初始化值
局部变量： 没有默认的初始化值，必须先定义，赋值，才能使用。
public class Variable {
/**
* @Fields x : 成员变量x
*/
int x;
/**
* @Title: show
* @Description: 显示变量
*/
public void show(){
//局部变量
int y=0;
System.out.println(x);
System.out.println(y);
}
}
2.5 类名作为形式参数和返回值
2.5.1 类名作为形式参数案例
要的其实是该类的对象
2.5.1.1 案例
public class Student {
/**
* @Title: study
* @Description: 学习方法
*/
public void study(){
System.out.println("好好学习，天天向上");
}
}
public class Teacher {
/**
* @Title: test
* @Description: 测试学生学习的方法
* @param s
*/
public void test(Student s){
s.study();
}
}
//测试类
public class Test {
public static void main(String[] args) {
Teacher t=new Teacher();
Student s=new Student();
t.test(s);
}
}2.5.2 类名作为返回值案例
返回的其实是该类的对象
2.5.2.1 案例
public class Student {
/**
* @Title: study
* @Description: 学习方法
*/
public void study(){
System.out.println("好好学习，天天向上");
}
}
public class Teacher {
/**
* @Title: getStudent
* @Description: 获取学生对象
* @return
*/
public Student getStudent(){
Student s=new Student();
return s;
}
}
//通过Teacher对象得到Student对象，然后调用Student对象的方法
//如果方法的返回值是类名：其实返回的是该类的对象
public class Test {
public static void main(String[] args) {
Teacher t=new Teacher();
Student s=t.getStudent();
s.study();
}
}第3章 包及访问权限
3.1 包的概述及定义格式
3.1.1 包的概念
分包管理是组织软件项目结构的基本方式。我们将同类功能放到一个包中，方便管理。并且日常项目的分工也是以包作为边界。
包在文件系统中是以文件夹的形式存在的。类中定义的包必须与实际class文件所在的文件夹情况相统一，即定义包后，如果类在a包下，则生成的.class文件必须在a文件夹下，否则找不到类。
3.1.2 包的定义格式
使用公司域名反写，多级包全部小写，用”.”连接
如：极客营网址为igeekhome.com那么域名反写就为com.igeekhome
甲骨文公司oracle.com 那么域名反写就为 com.oracle
类中的定义格式： package 包名;
一般建议四级目录结构： - com org gov 根据当前项目的性质 - igeek 开发商名字，或者甲方的名字 - javase bank 项目名称 - entity dao service controller 层名称
编译时：直接编译java文件即可
运行时：由于类的全名是包含包名的，所以必须运行加入了包名的全类名
全类名 = 包名 + 类名 类似于：com.igeek.javase.day01.Student
总结：
1.是java程序管理资源的方式
2.为了避免类重名
3.2 类的全名访问
在访问类时，为了能够找到该类，使用类时，应该使用包含包名的类全名。
如：字符串String在使用时，可以按照如下方式访问：
java.lang.String s = “一个字符串”;
等价于 String s = “一个字符串”;
3.2.1 案例
Person类：
package com.igeek_02;
/**
* @ClassName: Person
* @Description: Person类
*
*/
public class Person {
/**
* @Fields name : 姓名
*/
private String name;
/**
* @Title: Person
* @param name
*/
public Person(String name) {
this.name=name;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
}其他包中的Person类：
package com.igeek_02.other;
/**
* @ClassName: Person
* @Description: Person类
*
*/
public class Person {
/**
* @Fields name : 姓名
*/
private String name;
/**
* @Title: Person
* @param name
*/
public Person(String name) {
this.name=name;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
}类全名创建对象测试类：
package com.igeek_02;
/**
* @ClassName: PackageDemo
* @Description: package包的作用
*
* 包:是java程序管理资源的方式
*
* 类中声明的包,必须与真正该.class文件所在的文件夹一致
*
* 声明格式:
* package 文件夹(包).文件夹(包).文件夹(包)...
*
* 如何带包使用其他的类:应该加入全名,即包名+类名
*/
public class PackageDemo {
public static void main(String[] args) {
//使用类全名访问JRE提供好的类
java.lang.String s = "abc";
System.out.println(s);
//使用类全名访问同包下的其他类
com.igeek_02.Person person=new com.igeek_02.Person("Jack");
person.setName("Rose");
System.out.println(person.getName());
//使用类全名访问不同包(跨包)下的其他类
com.igeek_02.other.Person person2=new com.igeek_02.other.Person("Rose");
System.out.println(person2.getName());
}
}3.3 带包的类访问
3.3.1 同包下省略包名
当被使用的类与使用的类在同一个文件夹下，或者被使用的类是java.lang包下时，我们通常可以省略掉类的包，直接使用类型，避免使用类全名。
3.3.2 跨包时导包访问
当被使用的类与使用的类不在同一个文件夹下时，我们可以通过导包的方式使用该类，避免使用类全名。
导包格式：
package后，class前
使用import 包名.包名.类名;
当多个文件夹下有相同的类名时，只能有一个导包使用，其他必须仍然书写全名。
当想一下导入包中多个类时，可以使用代表该包下的所有类。
3.3.3 案例
同包下的Person类：
package com.igeek_03;
/**
* @ClassName: Person
* @Description: Person类
*
*/
public class Person {
/**
* @Fields name : 姓名
*/
private String name;
/**
* @Title: Person
* @param name
*/
public Person(String name) {
this.name=name;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
}com.igeek_03.other1包下的PersonOther类：、
package com.igeek_03.other1;
/**
* @ClassName: PersonOther
* @Description: PersonOther类
*
*/
public class PersonOther {
/**
* @Fields name : 姓名
*/
private String name;
/**
* @Title: Person
* @param name
*/
public PersonOther(String name) {
this.name=name;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
}com.igeek_03.other2包下的PersonOther类：
package com.igeek_03.other2;
/**
* @ClassName: PersonOther
* @Description: PersonOther类
*
*/
public class PersonOther {
/**
* @Fields name : 姓名
*/
private String name;
/**
* @Title: Person
* @param name
*/
public PersonOther(String name) {
this.name=name;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
}不同包中各个类的导入测试类：
package com.igeek_03;
//导包声明
import com.igeek_03.other1.PersonOther;
//不能导入相同名称的类,所以,当多个文件夹下有相同的类名时，只能有一个导包使用，其他必须仍然书写全名
//import com.igeek_03.other2.PersonOther;
/**
* @ClassName: PackageAccessDemo
* @Description: 不同包下面各个类的访问方式
*
* JRE提供的java.lang包下的类,是可以直接使用类名,无需加包名的,比如String
*
* 同包访问时,可以省略全名,使用类名
*
* 跨包访问:
* 可以不使用全名,使用导包的方式声明出要使用的类时哪个
*
* 导包格式：
* package后，class前
* 使用import 包名.包名.类名;
*/
public class PackageAccessDemo {
public static void main(String[] args) {
//JRE提供的lang包下的类,是可以直接使用类名,无需加包名的,比如String
String s = "hit the road";
//同包访问时,可以省略全名,使用类名
Person person = new Person("Jack");
System.out.println(person.getName());
//跨包访问,需要先导包,再使用
PersonOther Person2 = new PersonOther("Rose");
System.out.println(Person2.getName());
//不能导入相同名称的类,所以,当多个文件夹下有相同的类名时，只能有一个导包使用，其他必须仍然书写全名
com.igeek_03.other2.PersonOther Person3 = new
com.igeek_03.other2.PersonOther("Rose");
System.out.println(Person3.getName());
}
}3.4 访问权限
3.4.1 四种权限访问修饰符
在Java中提供了四种访问权限，使用不同的访问权限时，被修饰的内容会有不同的访问权限，以下表来说明不同权限的访问能力：
| public | protected | 空的(default) | private | |
|---|---|---|---|---|
| 同一类中 | √ | √ | √ | √ |
| 同一包中(子类与无关类) | √ | √ | √ | |
| 不同包的子类 | √ | √ | ||
| 不同包中的无关类 | √ |
归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问
l 要想仅能在本类中访问使用private修饰；
l 要想本包中的类都可以访问不加修饰符即可；
l 要想本类的子类可以访问使用protected修饰
l 要想任意包中的任意类都可以访问使用public修饰。
l 注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
第4章 封装
4.1 什么是封装
4.1.1 封装概述
是面向对象三大特征之一
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像上章说的年龄。
4.1.2 封装原则
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
成员变量private，提供对应的getXxx()/setXxx()方法
4.1.3 好处
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性，实现代码的组件化设计。
4.2 private关键字
4.2.1 private关键字
是一个权限修饰符。
可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。
4.2.2 案例
/**
* 通过对象直接访问成员变量，会存在数据安全问题
* 这个时候，我们就想能不能不让外界的对象直接访问成员变量呢？
* 能！
* 如何实现呢？
* private关键字
*
* private：
* 是一个权限修饰符。
* 可以修饰成员(成员变量和成员方法)
* 被private修饰的成员只能在本类中才能访问。
*
* 针对private修饰的成员变量，我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值，方法用 public修饰
*/
public class Student {
/**
* @Fields name : 姓名
*/
String name;
/**
* @Fields age : 年龄
*/
//int age;
private int age;
/**
* @Title: setAge
* @Description: 设置年龄
* @param a
*/
public void setAge(int a){
if(a<0||a>200){
System.out.println("你给的年龄有误");
}else{
age=a;
}
}
/**
* @Title: getAge
* @Description: 获取年龄
* @return
*/
public int getAge(){
return age;
}
/**
* @Title: show
* @Description: 显示学生信息
*/
public void show(){
System.out.println("姓名是："+name+"，年龄是："+age);
}
}
//测试类
public class StudentDemo {
public static void main(String[] args) {
//创建学生对象
Student s=new Student();
s.show();
s.name="林青霞";
//s.age=28;
//s.age=-28;
//s.setAge(-28);
s.setAge(28);
s.show();
}
}4.2.3 private最常见的应用
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
一个标准的案例的使用
public class Student {
/**
* @Fields name : 姓名
*/
private String name;
/**
* @Fields age : 年龄
*/
private int age;
/**
* @Title: setName
* @Description: 设置姓名
* @param n
*/
public void setName(String n){
name=n;
}
/**
* @Title: getName
* @Description: 获取姓名
* @return
*/
public String getName(){
return name;
}
/**
* @Title: setAge
* @Description: 设置年龄
* @param a
*/
public void setAge(int a){
age=a;
}
/**
* @Title: getAge
* @Description: 获取年龄
* @return
*/
public int getAge(){
return age;
}
}
//测试类
public class StudentDemo {
public static void main(String[] args) {
//创建学生对象
Student s=new Student();
System.out.println(s.getName()+"---"+s.getAge());
s.setName("吴京");
s.setAge(35);
System.out.println(s.getName()+"---"+s.getAge());
}
}4.3 this关键字
this: 代表所在类的对象引用
记住： 方法被哪个对象调用，this就代表那个对象
什么时候使用this呢? 局部变量隐藏成员变量
package com.igeek_02;
/**
* @ClassName: Student
* @Description: 学生类
*
* 起名字我们要求做到见名知意。
* 而我们现在的代码中的n和a就没有做到见名知意，所以我们要改进。
*
* 如果有局部变量名和成员变量名相同，在局部使用的时候，采用的是就近原则。
*
* 我们有没有办法把局部变量的name赋值给成员变量的name呢？有
*
* 什么办法呢？
* 用this关键字就可以解决这个问题。
*
* this: 代表所在类的对象引用
* 方法被哪个对象调用，this就代表那个对象
*
* 使用场景：局部变量隐藏成员变量
*/
public class Student {
/**
* @Fields name : 姓名
*/
private String name;
/**
* @Fields age : 年龄
*/
private int age;
/**
* @Title: setName
* @Description: 设置姓名
* @param n
*/
public void setName(String name){//吴京
//name=name;
this.name=name;
}
/**
* @Title: getName
* @Description: 获取姓名
* @return
*/
public String getName(){
return name;
}
/**
* @Title: setAge
* @Description: 设置年龄
* @param a
*/
public void setAge(int age){
//age=age;
this.age=age;
}
/**
* @Title: getAge
* @Description: 获取年龄
* @return
*/
public int getAge(){
return age;
}
}public class StudentDemo {
public static void main(String[] args) {
//创建学生对象
Student s=new Student();
System.out.println(s.getName()+"---"+s.getAge());
s.setName("吴京");
s.setAge(35);
System.out.println(s.getName()+"---"+s.getAge());
}
}4.4 构造方法
4.4.1 构造方法作用概述
给对象的数据进行初始化
4.4.2 构造方法格式
方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值
/**
* @ClassName: Student
* @Description: 学生类
*
* 构造方法：
* 给对象的数据进行初始化
*
* 格式：
* 方法名与类名相同
* 没有返回值类型，连void都没有
* 没有具体的返回值
*
*/
public class Student {
/**
* @Title: Student类的无参构造方法
*/
public Student(){
System.out.println("这是构造方法");
}
}
//测试类
public class StudentDemo {
public static void main(String[] args) {
//如何调用构造方法呢？
//通过new关键字调用
//格式：类名 对象名 = new 构造方法(...);
//也就是创建对象的格式
Student s=new Student();
}
}4.4.3 构造方法注意事项
如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的
/**
* @ClassName: Student
* @Description: 学生类
*
* 构造方法：
* 给对象的数据进行初始化
*
* 格式：
* 方法名与类名相同
* 没有返回值类型，连void都没有
* 没有具体的返回值
*
* 构造方法注意事项:
* A:如果你不提供构造方法，系统会给出一个默认无参构造方法
* B:如果你提供了构造方法，系统将不再提供默认无参构造方法
* 这个时候，如果想使用无参构造方法，就必须自己提供
* 推荐：自己给出无参构造方法
* C:构造方法也是可以重载的
*
* 成员变量赋值：
* A：setXxx()方法
* B：带参数构造方法
*/
public class Student {
/**
* @Fields name : 姓名
*/
private String name;
/**
* @Fields age : 年龄
*/
private int age;
/**
* @Title: Student类的无参构造方法
*/
/*
public Student(){
System.out.println("这是构造方法");
}*/
public Student(){}
/**
* @Title: Student
* @param name
*/
public Student(String name){
this.name=name;
}
/**
* @Title: Student
* @param age
*/
public Student(int age){
this.age=age;
}
/**
* @Title: Student
* @param name
* @param age
*/
public Student(String name,int age){
this.name=name;
this.age=age;
}
/**
* @Title: show
* @Description: 显示学生信息方法
*/
public void show(){
System.out.println(name+"---"+age);
}
}//测试类
public class StudentDemo {
public static void main(String[] args) {
//如何调用构造方法呢？
//通过new关键字调用
//格式：类名 对象名 = new 构造方法(...);
//也就是创建对象的格式
//public Student()
Student s=new Student();
s.show();
//public Student(String name)
Student s2=new Student("吴京");
s2.show();
//public Student(int age)
Student s3=new Student(35);
s3.show();
//public Student(String name,int age)
Student s4=new Student("吴京", 35);
s4.show();
}
}4.5 标准类的代码写法和测试
4.5.1 类
-
成员变量
-
构造方法
无参构造方法
带参构造方法
-
成员方法
getXxx()
setXxx()
4.5.2 给成员变量赋值的方式
无参构造方法+setXxx()
带参构造方法
/** * 无参构造方法 构造方法作用，创建实例（对象） * 1.方法没有返回值，也没有void * 2.构造方法的方法名必须与类名一致 * 3.无参构造方法中，没有形参列表 *//** * 有参构造方法 * 1.方法没有返回值，也没有void * 2.构造方法的方法名必须与类名一致 * 3.有参构造方法中的形参，往往是与属性一致的 * 4.this.属性名 = 形参; 赋值 this此时指的就是正在创建的对象 * 5.一旦一个类中提供了有参构造方法，将不会提供默认的无参构造方法 *//** * 构造方法存在方法重载 * 1.同一个类中 * 2.方法名相同的(都是与类名一致的) * 3.参数列表不同 */
346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
