课前预习笔记：
一、this关键字
1.this的作用
this表示的是当前对象本身
更准确地说，this代表当前对象的一个引用
2.普通方法中使用this
区分类成员属性和方法的形参
调用当前对象的其他方法（可省略）
位置：任意
3.构造方法中使用this
使用this来调用其它构造方法
位置：必须是第一条语句
4.this不能用于static方法
二、static关键字
1.在类中，用static声明的成员变量为静态成员变量 ，或者叫做：类属性，类变量
它为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化
对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享
可以使用”对象.类属性”来调用。不过，一般都是用“类名.类属性”
static变量置于方法区中
2.用static声明的方法为静态方法
不需要对象，就可以调用(类名.方法名)
在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员
静态方法不能以任何方式引用this和super关键字
3.static关键字
使用static声明的成员变量称为静态变量
使用static声明的方法称为静态方法
静态变量不静态方法又称为类变量和类方法
4.静态属性的访问形式
对象名.属性
类名.属性
5.静态方法
访问修饰符static返回值类型 方法名(){}
6.访问形式
对象名.方法名()
类名.方法名()
7.常见错误
调用本类的非静态方法
在方法里不可以定义static变量
8.static修饰与非static修饰的区别
| static、非private修饰 | 非static、private修饰 | |
|---|---|---|
| 属性 | 类属性、类变量 | 实例属性、实例变量 |
| 方法 | 类方法 | 实例方法 |
| 调用方法 | 类名.属性、类名.方法() 对象.属性、对象.方法() | 对象.属性、对象.方法() |
| 归属 | 类 | 单个对象 |
三、代码块
1.概念:使用”{}”括起来的一段代码
2.分类：根据位置可分类
普通代码块—>直接在方法或语句中定义的代码块
构造代码块—>直接写在类中的代码块
静态代码块—>使用static声明的代码块
同步代码块—>多线程的时候会学到
3.静态初化块
①如果希望加载后，对整个类进行某些初始化操作，可以使用static初始化块
②类第一次被载入时先执行static代码块；类多次载入时，static代码块只执行一次；static经常用来进行static变量的初始化
③是在类初始化时执行，不是在创建对象时执行
④静态初始化块中不能访问非static成员
四、package
1.为什么需要package?
为了解决类之间的重名问题
为了便于管理类：合适的类位于合适的包
2.package怎么用?
通常是类的第一句非注释性语句
包名：域名倒着写即可，再加上模块名，并不内部管理类
3.注意事项：
写项目时都要加包，不要使用默认包
com.gao和com.gao.car，这两个包没有包含关系，是两个完全独立的包。只是逡辑上看起来后者是前者的一部分
4.JDK中的主要包
java.lang
包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能
java.awt
包含了构成抽象窗口工具集（abstractwindow toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)
java.net
包含执行不网络相关的操作的类
java.io
包含能提供多种输入/输出功能的类
java.util
包含一些实用工具类，如定义系统特性、使用不日期日历相关的函数
五、Import
1.为什么需要import?
如果不适用import，我们如果用到其他包的类时，只能这么写：java.util.Date，代码量太大，不利于编写和维护。通过import可以导入其他包下面的类，从而可以在本类中直接通过类名来调用。
2.import怎么使用?
importjava.util.Date；
importjava.util.*;//导入该包下所有的类。会降低编译速度，但不会降低运行速度。
3.注意要点
java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用
如果导入两个同名的类，只能用包名+类名来显示调用相关类：
java.util.Datedate= newjava.util.Date()；
4.import static
静态导入的作用：用于导入指定类的静态属性
JDK5.0后增加
如何使用：
importstaticjava.lang.Math.*;//导入Math类的所有静态属性
importstaticjava.lang.Math.PI;//导入Math类的PI属性
然后，我们可以在程序中直接使用：System.out.println(PI);
六、封装
1.为什么要使用封装？
下面代码有什么缺陷？
Dog d = new Dog();
d.health = -1000;//属性随意访问，不合理的赋值
如何解决上面设计的缺陷？
使用封装
2.什么是封装？
面向对象三大特征之一——封装
封装的概念
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
封装的好处
只能通过规定方法访问数据
隐藏类的实现细节
方便加入控制语句
方便修改实现
3.隐藏/封装(encapsulation)
为什么需要封装？封装的作用和含义？
我要看电视，只需要按一下开关和换台就可以了。有必要了解电视机内部的结构吗？有必要碰碰显像管吗？
我要开车，….
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性
我们程序设计要追求“高内聚，低耦合”
高内聚就是类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅暴露少量的方法给外部使用
4.如何使用封装
①修改属性的可见性—>设为private
②创建共有的getter/setter方法—>用于属性的读写
③在getter/setter方法中加入属性控制语句—>对属性值的合法性进行判断
七、面向对象的三大特征
1.继承inheritance
子类父类
子类可以从父类继承属性和方法
子类可以提供自己单独的属性和方法
2.封装/隐藏encapsulation
对外隐藏某些属性和方法
对外公开某些属性和方法
3.多态polymorphism
为了适应需求的多种变化，使代码变得更加通用
4.面向过程只有封装性（功能的封装，而没有数据的封装），没有继承和多态
八、使用访问控制符，实现封装
1.成员（成员变量或成员方法）访问权限共有四种
①public 公共的
可以被项目中所有的类访问。(项目可见性)
②protected受保护的
可以被这个类本身访问；同一个包中的所有其他的类访问；被它的子类（同一个包以及不同包中的子类）访问
③default／friendly默认的/友好的（包可见性）
被这个类本身访问；被同一个包中的类访问。
④private私有的
只能被这个类本身访问。（类可见性）
2.类的访问权限只有两种
①public 公共的
可被同一项目中所有的类访问。(必须不文件名同名)
②default／friendly默认的/友好的
可被同一个包中的类访问
3.成员和类的访问权限表格
| 同一个类 | 同一个包中 | 子类 | 所有类 | |
|---|---|---|---|---|
| private | ❀ | |||
| default | ❀ | ❀ | ||
| protected | ❀ | ❀ | ❀ | |
| public | ❀ | ❀ | ❀ | ❀ |
4.封装要点
类的属性的处理:
①一般使用private.(除非本属性确定会让子类继承)
②提供相应的get/set方法来访问相关属性.这些方法通常是public，从而提供对属性的读取操作。（注意：boolean变量的get方法是用：is开头!）
一些只用于本类的辅助性方法可以用private，
希望其他类调用的方法用public
九、总结
1.方法调用中的参数传递（重中之重）
基本数据类型的参数传递：不能改变参数的值
引用数据类型的参数传递：不能改变参数的值
2.this
This代表当前对象自身的引用（必须new）
This可以修饰属性，区别成员变量和局部变量
This修饰方法–This修饰构造方法（必须是第一条语句）
3.static
static变量：只有一份，属于类，可以类名. Static变量
static方法: 类名.Static方法，不能出现this和super
static代码块：只执行一次，最早执行的（类第一次调用）
4.package import
包：作用
导入：importcom.bjsxt.oop.*;
静态导入：import static java.lang.Math.PI
课堂笔记：
一、this:
1.概念
表示当前对象的指针
指向当前对象，表示当前对象的引用
2.用途
①构造方法中：
当构造方法中的参数名称跟类的成员变量名称一样的时候，可以使用this代表当前对象
注意：
有了this之后，就可以将构造方法的参数跟成员变量保持一致（符合命名规范）
当构造方法中需要调用其他的构造方法时，可以使用this(参数列表)调用其他构造方法，但是必须
位于方法体的第一行（规则）
②普通方法中：
当多个普通方法之间需要相互调用的时候，可以使用this来进行调用，指的是当前对象的其他方法
③调用成员变量的时候如何使用？
当方法中的参数名称跟成员变量保持一致的时候，使用 this.变量名称 表示的是对象的值，而使用
变量名称表示形参列表中的值
二、static
1.概念
①修饰成员变量的时候，表示静态成员变量或者叫类变量
普通变量在使用的时候，必须要通过对象名进行调用
类变量或者静态变量可以使用对象名调用也可以使用类名进行调用
②修饰方法的时候，表示静态方法或者叫类方法
普通方法在使用的时候，必须要通过对象名进行调用
类方法或者静态方法可以使用类名，也可以使用对象名
2.注意：
①静态变量，在创建对象之前被初始化，或者说在类被载入之前进行初始化
②静态变量被所有的对象共享，属于公共变量，对象和类都可以直接调用，但是推荐使用类来调用
③成员变量放在堆中，而静态变量放在方法区中的静态区中
④静态变量不能定义在静态方法中
⑤静态方法可以在非静态方法中进行调用
⑥静态方法中不能直接调用非静态方法,换句话说可以间接调用非静态方法
⑦静态方法中不允许出现this调用
⑧一般工具类中的方法定义为static
三、代码块
1.概念
使用{}括起来的一段代码叫做代码块
2.分类
①普通代码块
定义在方法中，使用{}括起来的代码叫做普通代码块
②构造代码块
定义在类中的使用{}括起来的代码叫做构造代码块
注意：
每次代码运行的时候会将构造代码块中的代码添加到构造方法的前面
构造代码块中的代码会添加到每一个构造方法中，当使用this(参数)的时候不会添加
③静态代码块
使用static{}括起来的代码叫做静态代码块，在程序载入的时候优先执行
数据库连接等其他提前需要准备好的代码会放在static代码块
④同步代码块
在使用多线程的时候会使用，用来给共享空间进行加锁操作（后面讲）
⑤执行顺序
静态代码块—>构造代码块（创建对象的时候才会用到）—>普通代码块
四、package
1.概念
包，对应到文件系统就是多级目录
2.为了解决两个问题：
文件同名问题
为了方便管理类，将具体处理功能的代码放到同一个目录下
3.使用：
一般定义package会放置在java文件的第一行
package 域名的倒写
比如：www.taobao.com
包名：com.taobao.
package com.tensent.项目名称
4.包名的命名规则：
企业性质.企业名称.项目名称.模块名称. 子模块名称....
企业性质:com org edu gov
企业名称：alibaba baidu huawei tensent
项目名称：oa erp hrms crm
模块名称：
ums--userManagementSystem 用户管理系统
oms--orderManagementSystem 订单管理系统
pms--productManagementSystem 产品管理系统
完整的包名：com.alibaba.taobao.ums/com.alibaba.taobao.oms
完全限定名： 包名+类名
5.JDK中常用的包
lang：不需要手动导入，自动加载
awt： 包含了一些GUI图形界面常用的类（这个现在已经不用了，了解即可）
util: 工具包
net: 网络包
io: 输入输出流包
五、import
1.概念：
当需要引入非lang包的其他java类的时候，需要使用import工具
如果不使用import，每次在使用某个类的时候必须要将类的完全限定名都加上才可以使用，太过于
繁琐
2.用法：
import java.包名.类名；导入具体的类 推荐使用
import 包名.*; 将当前包下的所有类文件都进行导入,不推荐，因为它不会影响运行速度，但是会
影响编译的速度
3.注意：
当一个java文件中需要使用多个同名的类的时候，只能选择导入一个，另一个使用完全限定名的方
式进行导入
4.静态导包：
当需要使用某个类的多个方法的时候，同时又不想频繁写该类的名称，此时可以使用静态导包
六、封装
1.概念：
将类的某些信息隐藏在类内部，不允许外部程序直接访问，
而是通过该类提供的方法来实现对隐藏信息的操作和访问
2.封装解决什么问题：
如果任何一个处理类都可以直接对Dog进行赋值操作，那么当值不准确的时候，可以会产生意想不
到的结果
3.如何在赋值的同时添加一些逻辑判断呢？
封装可以解决此问题
4.作用：
使用封装可以保证数据的规范，不符合规范的数据将无法进行操作
5.好处：
隐藏类的内部实现细节
只能通过提供的方法进行访问，其他方法无法访问
可以根据需求添加复杂的逻辑判断语句
方便修改实现
6.面向对象的封装（狭义）可以用一句话概述：
为了保证数据安全和规范
将类中的属性设置为私有属性，提供公有的外部方法供程序进行调用，可以实现丰富的细节操作
7.广义的封装：
可以将完成特定功能的代码块封装成一个方法，供不同的程序进行调用
8.定义类的时候需要包含以下组件：
私有属性
构造方法（无参构造方法和自定义构造方法)
set/get方法
普通方法
七、面向对象的三大特征
同上的课前预习笔记
八、使用访问控制符，实现封装
在java中明确定义了访问权限：
限制访问，以下分类按照从大到小进行排列
1.public:公共的
当前项目的所有的类都可以进行访问
2.protected:受保护的
可以被当前类访问，可以被当前包访问，也可以被子类访问
3.default:默认权限
可以被当前类访问，可以被当前包访问，
4.private:私有权限
只能被当前类访问
注意：四种访问修饰符可以修饰属性和方法
类的访问修饰符只有两个 public default
九、值传递
方法参数的值是否改变
方法中的参数列表叫做形式参数，没有具体的值，只是为了方便在方法体中使用
调用方法的时候实际传入的值叫实际参数，代表具体的数值，用来替换在方法体中代码逻辑的值进
行运算
注意：
①形式参数的变量名称也是局部变量
②当方法的参数值是基本数据类型的时候，不会改变原来的值
③当方法的参数值是引用类型的时候，如果改变了该引用类型的值，会改变原来对象的值
java中的参数传递是值传递
十、总结
- this关键字的使用
- static关键字
- 代码块
- package
- import
- 封装
- 面向对象的三大特征
- 使用访问控制符，实现封装
- 值传递
课下作业：
//1.this测试代码
public class TextThis {
int a,b,c;
TextThis(){
System.out.println("正要new一个Hello对象");
}
TextThis(int a,int b){
this();
a = a;
this.a = a;
this.b = b;
}
TextThis(int a,int b,int c){
this(a,b);
this.c = c;
}
public void sing(){
}
public void chifan(){
this.sing();
System.out.println("你妈妈喊你回家吃饭！");
}
public static void main(String[] args) {
TextThis hi = new TextThis(1,2);
hi.chifan();
}
}
//2.static测试代码
public class TextStatic {
int a;
static int width;
static void gg(){
System.out.println("gg");
}
void tt(){
System.out.println("tt");
}
public static void main(String[] args) {
TextStatic hi = new TextStatic();
TextStatic.width = 2;
TextStatic.gg();
hi.gg();
gg();
}
}
//3.封装测试代码
public class Dog {
private String name = "旺财";
private int health = 100;
private int love = 0;
private String strain = "拉布拉多犬";
public int getHealth() {
return health;
}
public void setHealth(int health){
if(health > 100 || health < 0){
this.health = 40;
System.out.println("健康值应该在0和100之间，默认值是40");
}else{
this.health = health;
System.out.println("健康值是："+ health);
}
}
public String getName(){
return name;
}
public void setName(String name){
if(name.equals("")){
this.name = "旺财";
System.out.println("默认名字为：旺财");
}else{
this.name = name;
System.out.println("名字是：" + name);
}
}
public int getLove(){
return love;
}
public void setLove(int love){
if(love > 100 || love <0){
this.love = 60;
System.out.println("亲密值应该在0和100之间，默认值为：60");
}else{
this.love = love;
System.out.println("亲密值是：" + love);
}
}
public String getStrain(){
return strain;
}
public void setStrain(String strain){
if(strain.equals("")){
this.strain = strain;
System.out.println("默认品种为：拉布拉多犬");
}else{
this.strain = strain;
System.out.println("品种为：" + strain);
}
}
public static void main(String[] args) {
Dog dog = new Dog();
dog.setName("旺财");
dog.setHealth(85);
dog.setLove(95);
dog.setStrain("二哈");
}
}
//4.设计Dog和penguin类
//狗
public class DogAndPenguin {
static class Dog {
private String name = "小白";
private int health = 100;
private int love = 0;
private String strain = "二哈";
public String getName() {
return name;
}
public void setName(String name) {
if (name.equals("")) {
this.name = "小白";
System.out.println("默认昵称：" + "小白");
} else {
this.name = name;
System.out.println("昵称：" + name);
}
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
if (health > 100 || health < 0) {
this.health = 60;
System.out.println("健康值应该在0和100之间，默认值为：60");
} else {
this.health = health;
System.out.println("健康值：" + health);
}
}
public int getLove() {
return love;
}
public void setLove(int love) {
if (love > 100 || love < 0) {
this.love = 50;
System.out.println("亲密值应该在0和100之间，默认值为：50");
} else {
this.love = love;
System.out.println("亲密值：" + love);
}
}
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
if (strain.equals("")) {
this.strain = "二哈";
System.out.println("默认品种：二哈");
} else {
this.strain = strain;
System.out.println("品种：" + strain);
}
}
public static void main(String[] args) {
Dog dog = new Dog();
dog.setName("小白");
dog.setHealth(98);
dog.setLove(100);
dog.setStrain("茶杯狗");
}
}
//企鹅
static class Penguin{
private String name = "小迷";
private int health = 100;
private int love = 0;
private String gender = "女";
public String getName(){
return name;
}
public void setName(String name){
if(name.equals("")){
this.name = "小迷";
System.out.println("默认昵称：" + "小迷");
}else{
this.name = name;
System.out.println("昵称：" + name);
}
}
public int getHealth(){
return health;
}
public void setHealth(int health){
if(health > 100 || health <0){
this.health = 60;
System.out.println("健康值应该在0和100之间，默认值为：60");
}else{
this.health = health;
System.out.println("健康值：" + health);
}
}
public int getLove(){
return love;
}
public void setLove(int love){
if(love > 100 || love <0){
this.love = 50;
System.out.println("亲密值应该在0和100之间，默认值为：50");
}else{
this.love = love;
System.out.println("亲密值：" + love);
}
}
public String getGender(){
return gender;
}
public void setGender(String gender){
if(gender.equals("")){
this.gender = "女";
System.out.println("性别：女");
}else{
this.gender = gender;
System.out.println("性别：" + gender);
}
}
public static void main(String[] args) {
Penguin penguin = new Penguin();
penguin.setName("小晚");
penguin.setHealth(90);
penguin.setLove(83);
penguin.setGender("女");
}
}
}
//5.打印Dog信息2-1
public class Dog2 {
private String name = "小飞";
private String strain = "爱斯基摩犬";
private int health = 100;
public String getName(){
return name;
}
public void setName(String name){
if(name.equals("")){
this.name = "小飞";
System.out.println("默认昵称为：小飞");
}else{
this.name = name;
System.out.println("昵称是：" + name);
}
}
public String getStrain(){
return strain;
}
public void setStrain(String strain){
if(strain.equals("")){
this.strain = strain;
System.out.println("默认品种为：爱斯基摩犬");
}else{
this.strain = strain;
System.out.println("品种为：" + strain);
}
}
public int getHealth() {
return health;
}
public void setHealth(int health){
if(health > 100 || health < 0){
this.health = 70;
System.out.println("健康值应该在1和100之间，默认值是70");
}else{
this.health = health;
System.out.println("健康值是："+ health);
}
}
public static void main(String[] args) {
Dog dog = new Dog();
dog.setName("小白");
dog.setStrain("比熊犬");
dog.setHealth(96);
}
}
1528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
