JAVA初窥-DAY08
JAVA初窥-DAY08
-
- 面向过程与面向对象
- 实例化及调用普通方法和普通成员变量
- 静态成员方法与静态成员变量的调用
- 封装
- 构造方法
- 代码块
- 匿名对象
面向过程与面向对象
面向过程：注重的是某件事情过程中的每一个步骤的实现。
面向对象：把面向过程中的每一个步骤交给一个对象去管理，只需要去用这个对象即可。
类的语法：访问限定修饰符+class+类名（大驼峰） 访问限定修饰符可省略，一般面向对象不使用public来定义类。
类就相当于一个房子模板，通过这个模板可以建造很多的房子，而类（模板）可以产生很多对象（相当于实体），这个过程，就叫实例化。
每个类都由两部分组成，分别为属性和行为。
实现面向对象：开发的时候，找对象，创建对象，使用对象。
在main方法是static类型的，而在static类型中只能调用static类型的方法，如果要调用其他类的方法，则需要new一个对象，通过这个对象去调用方法，如：
public class Demo01{
public static void main(String[] args){
Person per = new Person();//实例化,现在Person中的lit是真正存在了
per.eat();//此时lit这个人调用eat方法，输出lit吃饭
per.sleep();
}
}
class Person{
//用class来定义类，Person为类名，此处建立一个叫Person的类
//1.属性 成员变量
public String name = "lit";
public int age = 18;
public String sex = "男";
//这里都是普通成员变量
public static int qqq = 0;//qqq为静态成员变量
//2.行为 成员方法
public void eat(){
//此处为普通成员方法
int aaa = 0;//局部变量
System.out.println(name+"吃饭！");
}
public void sleep(){
System.out.println(name+"睡觉！");
}
public static void zzz(){
//此处为静态成员方法
}
}
实例化及调用普通方法和普通成员变量
当用Person定义变量且new Person()后，用Person类型定义的变量就为一个对象，就可以利用这个对象去调用Person类里的方法，如：per.eat()。但是上面的代码每次new一个Person类型的变量时，属性都不变，则需：
public class Demo01{
public static void main(String[] args){
Person per = new Person();//实例化，创建对象
System.out.println(per.name);
System.out.println(per.age);
System.out.println(per.sex);
per.name = "lit";//引用.成员变量
per.age = 18;
per.sex = "男";
System.out.println(per.name);
System.out.println(per.age);
System.out.println(per.sex);
per.show();
}
}
class Person{
public String name;
public int age;
public String sex;
public void show(){
System.out.println("姓名："+name+"，年龄："+age+"，性别："+sex);
}
}
成员变量如果没有初始化，那么它的值就为所对应类型的默认值。
静态成员方法与静态成员变量的调用
静态成员方法与静态成员变量需要用类名来调用，如：
public class Demo01{
public static void main(String[] args){
Person per = new Person();
Person.qqq();//输出qqq方法被调用了
System.out.println(Person.count);//输出1
System.out.println(per.count);//合法，但不合理不推荐这么调用
}
}
class Person{
public static int count = 1;
public static void qqq(){
System.out.println("qqq方法被调用了");
}
}
静态成员变量及静态成员方法不依赖与对象
public static void main(String[] args){
Person per = null;
Person.qqq();//输出qqq方法被调用了
per.qqq();
System.out.println(per.age);
//空指针异常 普通成员变量会依赖对象 每个对象都有自己的属性和值 但是静态成员变量中，变量是跟对象没关系的，所以建议类名.静态变量/方法
}
}
class Person{
public int age = 10;
public static void qqq(){
System.out.println("qqq方法被调用了");
}
}
在这里，类就相当于一个班级，而对象就相当于班级里的人，而获奖可以理解为一个属性或方法，如果班级获奖了，那么获奖这个属性是班级的，也就是这个属性是类的，也就是静态成员属性，我们说班级里的人获奖了，可以是可以，合法不合理。但是如果班级里某人获奖了，此时为普通成员变量，只跟某个成员有关，我们就不能说班级获奖了，不合法也不合理。
同理，在静态成员方法中可以修改静态成员属性的值，可以调用静态成员方法。但是如果要调用普通成员方法，必须new一个对象，通过对象.方法/属性才可已调用。在普通成员方法里可以直接调用静态成员属性/方法。
public int name ;//普通成员变量，对象的属性，存储在对象内。
public static int count;//类变量也叫静态变量，属于类本身
public final SIZE;//常量，也属于对象。
public static final COUNT;//静态常量，属于类本身。
final修饰的常量一定要大写。常量顶以后不能修改。
封装
OOP思想：ObjectOrientedProgramming，就是面向对象的编程，OOD就是面向对象的设计，OOA就是面向对象的分析。
OOP的特征：继承、封装、多态。
什么是封装：使用关键字private来修饰成员变量或者成员方法，然后同意提供对应的get、set方法。这样做的好处是：类的调用者的使用类的成本大大降低。
public class Demo01{
public static void main(String[] args) {
Student stu = new Student();
stu.setName("lit");
stu.setAge(18);
stu.setSex("男");
stu.eat();
System.out.println(stu.getName());
System.out.println(stu.getAge());
System.out.println(stu.getSex());
stu.toString()
}
}
class Student{
private String name;
private int age;
private String sex;
public void eat(){
System.out.println(name+"eat");
}
public String getName() {
//ALT + INS 快捷键选择getter and setter
return name;
}
public void setName(String name) {
//此处的局部变量若跟普通成员变量的变量名一样的话，则写为name=name;但是会被默认为两个name都为局部变量，所以引入this工具
//在构造方法里this()只能在第一行使用表示的是对当前对象的引用。
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
// ALT+INS 快捷键选ToString
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
}
this的使用：this.data:访问成员变量，this.func():调用成员方法，this():调用构造方法 ，this虽然可以访问静态成员变量/方法，但是还是建议用类名去访问，而在静态方法内部，不能用this
构造方法
构造方法就是没有返回值的一个方法，且方法名和类名相同。
每个类会有一个默认的不带参数的构造方法，当一个类提供了其他的构造方法，那么编译器将不会帮我们自动生成不带有参数的构造方法。
实例化一个对象分为两步，为对象分配内存、调用合适的构造方法。这就意味着构造方法不止一个。
构造方法完成之后，你才真正有了一个对象。
而this就代表当前对象的引用
public static void main(String[] args){
Person per1 = new Person();//调用不带有参数的构造方法
Person per2 = new Person("lit");//调用带有参数的构造方法
}
}
class Person{
public String name = "lit";
public int age = 10;
public Person(){
//不带有参数的构造方法
this(caocao);//调用带有一个参数的构造方法，此时this()只能放在第一行。
}
public Person(String name){
//带有参数的构造方法
this.name = name;//把传过来的参数给普通成员变量
}
}
代码块
本地代码块：
实例代码块：也叫构造代码块，一般初始化实例数据成员，每new一个对象就执行一次
静态代码块：只能初始化静态数据成员，只会执行一次
执行顺序：先执行静态的，再执行实例的，若有多个静态或实例，则按顺序来
public static void main(String[] args){
Person per1 = new Person();
System.out.println(per1.age);
System.out.println(Person.count);
System.out.println("--------------------------");
Person per2 = new Person();
System.out.println(per2.age);
System.out.println(Person.count);
}
}
class Person{
{
//实例代码块
age = 20;
System.out.println("11111111");
}
static {
//静态代码块
count = 2;
System.out.println("22222222");
}
public String name = "lit";
public int age = 10;
public static int count =1
static {
couynt = 3;
System.out.println("33333333");
}
{
age = 30;
System.out.println("44444444");
}
}
匿名对象
如果某个对象只需调用一次，则可以使用匿名对象。
new Person().eat();//之后找不到这个对象，因为没有对象名。