面向对象思想
把步骤和功能进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。
面向对象思想特点
1.是一种更符合我们思想习惯的思想；
2.可以将复杂的事情简单化；
3.将我们从执行者变成了指挥者；
面向对象特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
类和对象的概念
类：是一组相关的属性和行为的集合；
对象：是该类事物的具体体现；
事物 ------------------ 类
属性 ----------------- 成员变量
行为 ----------------- 成员方法
定义类其实就是定义类的成员(成员变量和成员方法)
成员变量： 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
成员方法： 和以前定义方法是一样的，只不过把static去掉。
属性 ----- 成员变量
行为 ----- 成员方法
如何使用类
类是一个抽象的概念，你无法直接使用，要使用类中的属性功能，必须创建该类对象；
1.文件名问题
在一个java文件中写两个类：一个基本的类，一个测试类。
建议：文件名称和测试类名称一致。
2.如何使用呢?
创建对象使用。
3.如何创建对象呢?
格式：类名 对象名 = new 类名();
4.如何使用成员变量呢?
格式：对象名.变量名
5.如何使用成员方法呢?
格式：对象名.方法名(…)
成员变量和局部变量的区别
1.在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上（形参）
2.在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
3.生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
4.初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
注意:局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
方法的形式参数是类名的时候如何调用
1.Java中参数传递问题
形式参数
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数2.方法的参数是类名
如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
基本数据类型，作为参数传递，形参的改变，不影响实参
引用输入类型，作为参数传递，形参的改变，会影响实参
public class MyTest {
public static void main(String[] args) {
//基本数据类型，作为参数传递，形参的改变，不影响实参
//引用输入类型，作为参数传递，形参的改变，会影响实参
//引用数据类型：数组，类，接口
Dog dog = new Dog();
//如果你以后看到一个方法的形参，要一个 类 类型 那么你就传一个该类的对象
String name = "小花";
int num = 100;
dog.show(dog, name, num);
System.out.println(dog.name);// kitty
System.out.println(dog.age);// 101
System.out.println(name);// 小花
System.out.println(num);// 100
}
}
class Dog {
String name;
int age;
public void show(Dog dog1, String name, int num) {
System.out.println("这个方法调用了");
name = "kitty";
num = 100 + 1;
dog.name = name;
dog.age = num;
System.out.println(name);// kitty
System.out.println(num);//101
}
}匿名对象
1.什么是匿名对象？
就是没有名字的对象；
2.匿名对象应用场景
a:调用方法，仅仅只调用一次的时候；
b:匿名对象可以作为实际参数传递。
封装
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
1.封装好处
隐藏实现细节，提供公共的访问方式；
提高了代码的复用性；
提高安全性；
2.封装原则
将不需要对外提供的内容都隐藏起来；
把属性隐藏，提供公共方法对其访问；
private关键字
1.特点
a:是一个权限修饰符；
b:可以修饰成员变量和成员方法；
c:被其修饰的成员只能在本类中被访问；
2.private最常见的应用：
1)把成员变量用private修饰；
2)提供对应的getXxx()和setXxx()方法；
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
student.setName("张三");
student.setAge(20);
String name = student.getName();
int age = student.getAge();
System.out.println("姓名：" + name + "=== 年龄" + age);
student.eat();
student.sleep();
System.out.println("-------------------");
Student student1 = new Student();
student1.setName("李四");
student1.setAge(24);
String name1 = student1.getName();
int age1 = student1.getAge();
System.out.println("姓名：" + name1 + "=== 年龄" + age1);
student1.eat();
student1.sleep();
}
}
public class Student {
private String name;
private int age;
//提供公共的set方法，让外界调用set方法来给成员变量设置
public void setName(String mingzi) {
name = mingzi;
}
public void setAge(int nianling) {
age = nianling;
}
//提供get方法，让外界通过get方法，来获取成员变量的值
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void sleep() {
System.out.println("睡觉");
}
public void eat() {
System.out.println("吃饭");
}
}this关键字
1.为什么要有this？
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致局部变量隐藏成员变量。
2.this关键字特点？
是当前类的对象引用。
简单的记，它就代表当前类的一个对象。谁调用这个方法,那么该方法内部的this就代表谁。
3.this的应用场景？
解决局部变量隐藏成员变量。
public class MyTest {
public static void main(String[] args) {
Teacher teacher = new Teacher();
System.out.println("teacher的地址值" + teacher);
//通过set方法，来给成员变量设置值
teacher.setName("沈某某");
teacher.setAge(18);
//通过get方法来获取值
String name = teacher.getName();
int age = teacher.getAge();
System.out.println(name);
System.out.println(age);
//this:代表本类的一个引用，你可以理解为本类的一个对象，哪个对象调用某个方法，那么方法中的this就代表这个对象
System.out.println("--------------------");
Teacher teacher1 = new Teacher();
System.out.println("teacher1" + teacher1);
teacher1.setName("王五");
teacher1.setAge(25);
String name1 = teacher1.getName();
int age1 = teacher1.getAge();
System.out.println(name1);
System.out.println(age1);
}
}public class Teacher {
//私有成员变量
private String name;
private int age;
//提供公共的set方法
public void setName(String name) { //成员变量和局部变量重名了
System.out.println("this代表的那个对象" + this);
this.name = name;
//teacher.name=name;
}
public void setAge(int age) { //成员变量和局部变量重名了
System.out.println("this代表的那个对象" + this);
this.age = age;
}
//提供的公共的get方法
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
public void teache() {
System.out.println("教书");
}
}构造方法
1.作用
创建对象,给对象中的成员进行初始化。
2.构造方法格式特点
a:方法名与类名相同；
b:没有返回值类型，连void都没有；
c:没有具体的返回值；
3.构造方法注意事项
a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法。
4.给成员变量赋值的两种方式
setXxx()方法
构造方法
public class Student {
private String name;
private int age;
//我们自定义的一个类中，默认就会存在一个空参的构造方法
//构造方法，就是用来初始化这个类的，完成对类的实例化
public Student() {
System.out.println("空参的构造方法执行了");
}
public Student(String name) {
System.out.println(name);
System.out.println("一个参数的构造方法，执行了");
}
public Student(String name, int age) {
//System.out.println(name);
//System.out.println(age);
System.out.println("两个参数的构造方法，执行了");
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}空参构造方法与有参构造方法
public class MyTest {
public static void main(String[] args) {
//类，是一个抽象的概念，不能直接使用，要使用类中的属性和功能，必须对类进行实例化
// 我们可以使用关键字new
//我们在创建对象时，除了使用关键字new 之外 还得借助构造方法，来完成对类的实例化。
//借助空参的构造方法创建对象
Student student = new Student();
//借助有参的构造方法，创建对象
//Student student1 = new Student("zhangsan");
Student student2 = new Student("lisi", 24);
//System.out.println(student2.name);
//System.out.println(student2.age);
}
}public class MyTest2 {
public static void main(String[] args) {
//采用空参构造来创建对象
Student student = new Student();
student.setName("zhangsan");
student.setAge(13);
System.out.println(student.getName());
System.out.println(student.getAge());
System.out.println("--------------------------------");
//采用有参构造来创建对象，在创建对象的同时，就可以给成员变量赋值
Student student1 = new Student("wangwu", 25);
System.out.println(student1.getName());
System.out.println(student1.getAge());
}
}定义一个长方形(RectangleDemo) 类, 定义求周长(length) 和面积(area) 的方法,然后定义一个测试类Test，进行测试。
public class MyTest {
public static void main(String[] args) {
Rectangle rectangle = new Rectangle();
rectangle.setHeight(100);
rectangle.setWidth(200);
double perimeter = rectangle.getPerimeter();
double area = rectangle.getArea();
System.out.println("面积是"+area+"==周长是"+perimeter);
System.out.println("-------------------");
Rectangle rectangle1 = new Rectangle(10.3, 190.6);
double perimeter1 = rectangle1.getPerimeter();
double area1 = rectangle1.getArea();
System.out.println("面积是" + area1 + "==周长是" + perimeter1);
}
}public class Rectangle {
//定义属性
private double width;
private double height;
//提供构造方法
public Rectangle() {
}
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
//提供get set 方法
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
//提供获取周长的方法
public double getPerimeter() {
return (width + height) * 2;
}
//提供获取面积的方法
public double getArea() {
return width * height;
}
}static关键字
特点：
1.随着类的加载而加载；
2.优先于对象存在；
3.被类的所有对象共享；
什么时候使用静态?
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
注意：
1.在静态方法中是没有this关键字的；
2.静态方法只能访问静态的成员变量和静态的成员方法；
静态只能访问静态,非静态可以访问静态的也可以访问非静态的。
静态变量和成员变量的区别
1.所属不同
静态变量属于类，所以也称为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
2.内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
3.内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
4.调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
