目录
面向对象和面向过程
Java是一门纯面向对象的语言。C语言是面向过程的语言。二者区别可以类比成洗衣服。
面向过程：注重的是把衣服放到盆里，放水，放衣服，放洗衣粉，搓衣服等这些过程。
面向对象：把衣服放到洗衣机里洗，放洗衣粉即可。人不需要关注具体如何洗衣服的。
描述实体（对象）——类
上述的洗衣机就是一个实体对象，我们需要通过类来描述它，比如其功率，品牌，洗涤方式等。
类的定义
class Student {
String name;//以下三个叫 字段（成员变量）
int age;//主要为了描述类
String id;
public void studyKnowledge(){
System.out.println(name+"学习知识");
}//该方法叫 行为（成员方法）
//主要说明功能的
}小结：
1.通过关键字 class 定义类
2.成员变量、成员方法和类都需要进行限定。（下面讲）
3.类名为大驼峰形式（每个单词首字母大写）方法名为小驼峰（首单词字母小写）
4.一个Java文件中只写一个类（建议）
类的实例化——对象
上面我们只是把类定义出来了，还没有把它创造出来。（类的定义相当于是一张施工图纸，实例化就是建筑）。这个建筑就是对象。
//这个类是我用来测试其他类的类
//和上面的 创建的学生类 一起使用便完成了类的实例化
public class Test {
public static void main(String[] args) {
Student stu1=new Student();
stu1.name="zhangsan";
stu1.studyKnowledge();
Student stu2=new Student();
stu2.name="lisi";
stu2.studyKnowledge();
}
}
小结：
1.通过关键字 new 创建出一个 对象
2.通过 . 来访问其中的字段和方法
3.通过一个 类 可以创建多个对象 （一个图纸造很多房子）
4.创建出来的 对象 在堆区
this引用
先定义一个 Date 类
class Date {
int year;
int month;
int day;
void setDay(int y,int m,int d){
year = y;
month = m;
day = d;
}
void printDay(){
System.out.println(year+"-"+month+"-"+day);
}
}在Test类中通过 Date类 创建出d1 d2 d3 这三个对象，并通过Date类中的方法对其进行设置和打印
public class Test {
public static void main(String[] args) {
Date d1 = new Date();
Date d2 = new Date();
Date d3 = new Date();
d1.setDay(2000, 01, 01);
d2.setDay(2010, 02, 02);
d3.setDay(2020, 03, 03);
d1.printDay();
d2.printDay();
d3.printDay();
}
}
上面代码有两个问题
1.形参名不小心与成员变量名相同了怎么办？
void setDay(int year,int month,int day){
year = year;
month = month;
day = day;
}此时到底是谁给谁赋值？
2. 只通过 Date类new出多个对象时，其当中的方法，如何知道每次都是赋值和打印谁的。
这是便需要this引用了。
this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。
（引用可以简单的理解为C语言中的指针，指针指向当前对象，该对象只能是类中的成员方法）
this的引用特性
1.this类型：哪个对象调用，就是哪个对象的引用类型
2.使用范围：只能在成员方法中使用
3.在成员方法中，this只能引用当前对象
4.this是成员方法中的第一个参数（被隐藏），编译器会自动传递
在成员方法执行时，编译器会把调用成员方法对象的引用传递给该成员方法，this负责接 收
上面的代码就可以写成下面这样
class Date {
int year;
int month;
int day;
void setDay(Date this,int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
}
void printDay(Date this){
System.out.println(this.year+"-"+this.month+"-"+this.day);
}
}
对象的初始化
1.就地初始化
class Date {
int year = 2022;//就地初始化
int month = 8;
int day = 4;
void setDay(Date this,int y,int m,int d){
this.year = y;
this.month = m;
this.day = d;
}
void printDay(Date this){
System.out.println(this.year+"-"+this.month+"-"+this.day);
}
}2.用构造方法初始化
构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。
构造方法特性
1.名字和方法名相同
2.没有返回值
3.只调用一次，编译器自动调用
4.构造方法可以重载（必须名字相同，参数不同）
5.只是对对象初始化，不开辟空间
6.如果没有写出构造方法，编译器自动生成一个无参数的构造方法。写了就不再生成
7.大多数情况被public修饰，少数被private修饰
由以上特性，我们可以写出初始化刚才日期的第三种方法。
class Date {
int year;
int month;
int day;
//这是无参数的构造方法
public Date(){
this.year = 2022;
this.month = 8;
this.day = 4;
}
//这是有参数的构造方法，使用时需要传参
public Date(int y,int m,int d){
this.year = y;
this.month = m;
this.day = d;
}
//以上两个构造方法名字相同，参数类型不同，形成重载
// void setDay(Date this,int y,int m,int d){
// this.year = y;
// this.month = m;
// this.day = d;
// }
void printDay(Date this){
System.out.println(this.year+"-"+this.month+"-"+this.day);
}
}通过this调用其他构造方法
注：
1.this必须时当前构造方法的第一条语句。
2.调用其他的构造方法中不能有this，否则就形成循环了。
class Date {
int year;
int month;
int day;
//通过 this() 调用了下面的构造方法，并且在第一的位置
public Date(){
this(2022,8,4);
}
public Date(int y,int m,int d){
this.year = y;
this.month = m;
this.day = d;
}
// void setDay(Date this,int y,int m,int d){
// this.year = y;
// this.month = m;
// this.day = d;
// }
void printDay(Date this){
System.out.println(this.year+"-"+this.month+"-"+this.day);
}
}
3.实例代码块初始化
在下面的 代码块 中的 实例代码块。
4.默认初始化
局部变量不初始化而去使用它是，Java就会报错。
成员变量不初始化去使用它，各种类型默认会有初始化的值。
数据类型 默认值 byte 0 char '\u0000' short 0 int 0 long 0L boolean false float 0.0f double 0.0 reference null
封装
面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。
封装定义
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互
封装就像我们使用的电脑，内部的零件我们看不到，我们只需要通过键盘鼠标等使用电脑。
包
为了更好的管理类，把多个类收集在一起成为一组，称为软件包。这些类通常是有密切联系的。
对于包，我们不但得会使用现成的包，还得会创建一个包。
使用包
1.具体到类使用 import + 包 + XXX（类）;
import java.util.Arrays;
//这是 java.util包 中的一个和 数组有关的类
//在下面像使用的时候通过Arrays.XXX就可以使用里面的方法
2.只具体到包使用 import + 包 + * ;
import java.util.*;
// 仅仅导入了java下的 util 这个包
//要是后面要使用它里面的类时，它就会自动导入第二种情况使用时，会有以下问题：不同的包下面有相同的类名。到时候编译器就不知道该使用哪个包下面的类，就会报错。
import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
Date date = new Date();
System.out.println(date.getTime());
}
}解决方案：在实例化的时候明确指明用哪一个包下面的类
java.util.Date date = new java.util.Date();
3.使用import static导入包中静态的方法和字段
//import java.lang.Math.*;
import static java.lang.Math.*;
public class Test {
public static void main(String[] args) {
double x = 30.0;
double y = 40.0;
// 非静态方法写
// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
double result = sqrt(pow(x, 2) + pow(y, 2));
System.out.println(result);
}
}创建包
建好一个类的文件后，编译器会自己在第一行加上 package 包名;
访问限定符
Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：
public：全部的人都知道
default：只有部分的人知道（比如一个家族的人知道）
private：仅自己知道
注：
1.什么访问限定符都没有写就是default（default也不能写出来）
2.protected主要用在继承当中。
3.一般情况下成员变量设置为private，成员方法设置为public
static成员
在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对
象，是所有对象所共享的。
创建一个同一个班级的学生类（只有姓名和班级）：
public class Student {
private String name;
private String classes;
public void studyKnowledge(){
System.out.println(name+"学习知识");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getClasses() {
return classes;
}
public void setClasses(String classes) {
this.classes = classes;
}
}
public class Test {
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
Student s3 = new Student();
s1.setName("zhangsan");
s2.setName("lisi");
s3.setName("wangwu");
s1.setClasses("1班");
s2.setClasses("1班");
s3.setClasses("1班");
}
}可以看出，上面的班级是重复。我们可以把它变成静态成员。
private static String classes;静态成员在内存的分布：
程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址
虚拟机栈(JVM Stack): 与方法调用相关的一些信息，每个方法在执行时，都会先创建一个栈帧，栈帧中包含有：局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息，保存的都是与方法执行时相关的一些信息。比如：局部变量。当方法运行结束后，栈帧就被销毁了，即栈帧中保存的数据也被销毁了。
本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的
堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2,3} )，堆是随着程序开始运行时而创建，随着程序的退出而销毁，堆中的数据只要还有在使用，就不会被销毁。
方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域
static修饰成员变量、成员方法
修改上面代码如下：
public class Student {
private String name;
//这里图省事，直接使用就地初始化
//修饰成员变量
private static String classes = "1班";
public void studyKnowledge(){
System.out.println(name+"学习知识");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//因为成员被private限定，所以不能直接访问成员，需要通过公开的静态的方法间接访问
//修饰成员方法
public static String getClasses() {
return classes;
}
}
public class Test {
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
Student s3 = new Student();
s1.setName("zhangsan");
s2.setName("lisi");
s3.setName("wangwu");
//通过 类名.方法 就可以访问静态成员
System.out.println(Student.getClasses());
}
}static修饰类（内部类）
下面的内部类里面讲。
小结：
1.static修饰成员变量 类名.成员变量名 或者 当实例化出来一个对象后，也可以通过对象访问。但不建议这么做。
此时的成员变量不属于某个对象，不存储在类的空间，是类的属性，所有对象共享
随着类的加载而创建，类的销毁而销毁
不能再静态方法中访问非静态成员变量
2.static修饰成员方法 类名.成员方法名 或者 当实例化出来一个对象后，也可以通过对象访问。但不建议这么做。
此时的类方法不属于某个对象，是类方法
不能再静态方法中调用非静态成员方法
static成员变量初始化
1.就地初始化（上面代码就是就地初始化）
2.静态代码块初始化（代码块下面讲）
代码块
使用 {} 定义的一段代码称为代码块。
普通代码块
定义在方法中的代码块。没什么特别之处
public class Test {
public static void main(String[] args) {
System.out.println("这是一个普通的代码块！");
}
}构造代码块
定义在类中，该代码块不加修饰符。也叫做实例代码块，一般用于初始化实例成员变量。
public class Person {
private String name;
private int age;
private double height;
private double weight;
{
//这是一个实例代码块，正在初始化成员变量
name="zhangsan";
age=30;
height=180.0;
weight=75.0;
}
public void work(){
System.out.println(name+"正在工作！");
}
}静态代码块
只用static定义的代码块叫静态代码块。一般用于初始化静态成员变量
public class Person {
private String name;
private int age;
private double height;
private double weight;
private static String nationality;
//这是一个静态代码块，正在给静态成员变量赋值
static {
nationality = "Chinese";
}
public void work(){
System.out.println(name+"正在工作！");
}
}注意事项
public class Person { private String name; private int age; private double height; private double weight; private static String nationality; { name="zhangsan"; System.out.println("看看实例代码块是否执行"); } static { nationality = "Chinese"; System.out.println("看看静态代码块是否执行"); } public void work(){ System.out.println(nationality+" "+name+"正在工作！"); } public static void main(String[] args) { Person p = new Person(); Person p1=p; p.work(); p1.work(); System.out.println("******************"); Person p2=new Person(); p2.work(); } }
1. 静态代码快执行速度大于构造代码块
因为静态成员是类的属性，在JVM加载类时开辟空间并初始化的。静态代码块也是如此。
2.静态代码块只执行一次。
原因如上。
3.若有多个静态代码块，则按照顺序执行。
4.构造代码块只有实例化对象的时候才执行。
5.若有多个构造代码块，则按照顺序执行。
内部类
一个类中必须要有一个其他的类，这个类就是内部类。内部类有实例内部类，静态内部类，局部内部类。
实例内部类
未被static修饰的内部类。
class OuterClass {
private int date1 = 1;
private int date2 = 2;
public void outFunc(){
System.out.println("这是一个外部类的方法！");
}
class InnerClass{
private int date3 = 3;
private int date4 = 4;
public void inFunc(){
System.out.println("这是一个内部类的方法！");
}
}
}1.访问实例内部类成员
public class Test1 {
public static void main(String[] args) {
//外部类名.内部类名(引用类型) 变量 相当于 先实例化外部类.访问实例化内部类
OuterClass.InnerClass in = new OuterClass().new InnerClass();
in.inFunc();
//先实例化一个外部类 out
OuterClass out = new OuterClass();
// 引用类型 变量 变量访问内部成员
OuterClass.InnerClass in2 = out.new InnerClass();
in2.inFunc();
}
}
2.在实例内部类访问内外部类成员
class OuterClass {
private int date1 = 1;
private int date2 = 2;
public void outFunc(){
System.out.println("这是一个外部类的方法！");
}
class InnerClass{
private int date3 = 3;
private int date4 = 4;
public void inFunc(){
System.out.println("这是一个内部类的方法！");
System.out.println("这个内部类方法接下来要访问内外部类成员");
System.out.println(date1);
System.out.println(date2);
System.out.println(date3);
System.out.println(date4);
}
}
}
public class Test1 {
public static void main(String[] args) {
OuterClass out = new OuterClass();
OuterClass.InnerClass in = out.new InnerClass();
in.inFunc();
}
}
在内部类中出现 外部类 成员变量名 和内部类有相同的情况，优先访问内部类的成员变量。
若是非要访问外部类成员 通过 外部类名.this.成员变量名 方法访问。
class OuterClass {
private int date1 = 1;
private int date2 = 2;
private int same = 22;
public void outFunc(){
System.out.println("这是一个外部类的方法！");
}
class InnerClass{
private int date3 = 3;
private int date4 = 4;
private int same = 33;
public void inFunc(){
System.out.println("这是一个内部类的方法！");
System.out.println("这个内部类方法接下来要访问内外部类成员");
System.out.println(same);
System.out.println(OuterClass.this.same);
}
}
}
public class Test1 {
public static void main(String[] args) {
OuterClass out = new OuterClass();
OuterClass.InnerClass in = out.new InnerClass();
in.inFunc();
}
} 
3.不能出现静态成员变量
class InnerClass{
private int date3 = 3;
private int date4 = 4;
//这两个都是错误的
//private static int sta = 5;
//public static void f(){
// System.out.println("这是静态方法");
//}
//非要出现静态的,通过 static final 修饰
private static final int sta = 5;
public void inFunc(){
System.out.println("这是一个内部类的方法！");
}
}静态内部类
被static修饰的内部类
1.访问静态内部类成员
class OuterClass2 {
private int date1 = 1;
private int date2 = 2;
public void outFunc() {
System.out.println("这是一个外部类的方法！");
}
static class InnerClass2{
private int date3 = 3;
private int date4 = 4;
public void inFunc(){
System.out.println("这是一个静态内部类的方法");
}
}
}
public class Test2 {
public static void main(String[] args) {
//相较于实例内部类，不需要实例一个外部类，直接可以实例一个静态内部类直接访问
OuterClass2.InnerClass2 in2 = new OuterClass2.InnerClass2();
in2.inFunc();
}
}2.静态内部类访问外部类成员
class OuterClass2 {
private int date1 = 1;
private int date2 = 2;
private static int st1 = 66;
public void outFunc() {
System.out.println("这是一个外部类的方法！");
}
static class InnerClass2{
private int date3 = 3;
private int date4 = 4;
public void inFunc(){
System.out.println("这是一个静态内部类的方法");
System.out.println("这个静态内部类要访问外部类的成员了");
//在静态内部类中，只能访问外部静态类成员。
//System.out.println(OuterClass2.date1);
System.out.println(OuterClass2.st1);
//若想访问外部类中非静态类成员，只能先实例化一个外部类成员
OuterClass2 out2 = new OuterClass2();
System.out.println(out2.date1);
}
}
}
public class Test2 {
public static void main(String[] args) {
OuterClass2.InnerClass2 in2 = new OuterClass2.InnerClass2();
in2.inFunc();
}
}局部内部类
不能被public、static等关键字修饰。定义在方法内部，只能在该方法中使用。使用很少。
public void func(){
System.out.println("这是一个方法");
class Ineer{
private int date = 10;
public void innerFunc(){
System.out.println("这是局部内部类里面的一个方法");
}
}
}有什么错误希望评论区指出。
554
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
