Java面向对象(01)--初识
什么是面向对象
- 面向对象编程(Object-Oriented Programming, OOP)
- 面向对象的本质：以类的方式组织代码，以对象组织数据
- 抽象
- 三大特性
- 封装
- 继承
- 多态
- 对象，是具体的事物。类是抽象的，是对对象的抽象。
- 类是对象的模板
创建与初始化对象
- 使用
new关键字创建对象 - 使用
new关键字创建对象的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化及对类中构造器的调用 - 类的构造器也称为构造方法，是在进行创建对象时必须被调用的
- 构造器必须和类的名字相同
- 必须没有返回值，也不能写
void
Student.jaa
package oop.demo01;
public class Student {
// 属性
String name;
int age;
public void study(){
System.out.println(this.name + " the student is learning now!");
}
}
Person.java
package oop.demo01;
public class Person {
String name;
public Person(){
System.out.println("调用了无参构造方法！");
}
// 有参构造； 一旦定义了有参构造，无参构造必须显示定义
public Person(String name){
this.name = name;
}
}
Application.java
package oop.demo01;
// 一个项目应该只存有一个main方法
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(s1.name + " " + s1.age);
s1.name = "panky";
s1.age = 27;
System.out.println(s1.name + " " + s1.age);
s1.study();
Person p1 = new Person();
Person p2 = new Person("suki");
System.out.println("p1: " + p1.name + " p2: " + p2.name);
}
}
static关键字
1.static关键字 使用static关键字修饰一个属性，声明为static变量实质上就是全局变量 使用static关键字修饰一个方法，在一个类中定义一个方法为static 无需本类的对象即可调用此方法 使用static关键字修饰一个类
2.内存结构分析 存在方法区，静态数据不属于对象，属于类，直接用类名调用属性，而不是用对象调用属性 无法从静态上下文中引用非静态： 静态属性和方法在类加载后就存到方法区内存中，此时，还没有产生对象，而普通方法和属性 属于对象，所以不能调用
3.声明static的方法限制 仅能调用其他的static方法 只能访问static数据 不能以任何方式引用this或super
static关键字特点： 随着类的加载而加载，优先于对象存在，被所有对象所共享，可以直接被类名调用
static关键字使用注意： 静态方法只能访问静态成员，但是非静态成员可以访问静态成员; 静态方法中不可以使用this，super关键字
// 主方法是静态的
public static void main(String[] args)
static关键字的使用：
// 用static 修饰的成员表示它属于这个类共有，而不是属于该类的单个实例
static 修饰的字段 == 类字段
static 修饰的方法 == 类方法
Person.java
package oop.demo09;
public class Person {
// 2 赋初始值
{
// 匿名代码块
System.out.println("匿名代码块");
}
// 1 只执行1次
static {
// 静态代码块
System.out.println("静态代码块");
}
// 3
public Person(){
// 构造方法
System.out.println("构造方法");
}
public static void main(String[] args) {
Person p1 = new Person();
System.out.println("================== = new Person();
}
}
Student.java
package oop.demo09;
// static
public class Student {
private static int age; // 静态属性
private double score; // 非静态属性
public static void go(){
System.out.println("go");
}
public void run(){
System.out.println("run!");
}
public static void main(String[] args) {
Student s1 = new Student();
// 调用 静态属性和非静态属性
System.out.println(Student.age);
// System.out.println(Student.score); // 不可以调用 score
System.out.println(s1.age);
System.out.println(s1.score);
// 调用 静态方法和非静态方法
Student.go();
// Student.run(); // 编译报错， 不可调用
go();
s1.run();
s1.go();
}
}
instanceof
package oop;
import oop.demo08.Person;
import oop.demo08.Student;
import oop.demo08.Teacher;
public class Test {
public static void main(String[] args) {
// Object > String
// Object > Person > Teacher
// Object > Person > Student
// System.out.println(x instanceof y); // 能不能编译通过，要看，声明x的类，与y是否有类的父子关系
System.out.println("=================================");
Object object = new Student();
System.out.println(object instanceof Student); // true
System.out.println(object instanceof Person); // true
System.out.println(object instanceof Object); // true
System.out.println(object instanceof Teacher); // false
System.out.println(object instanceof String); // false
System.out.println("=================================");
Person person = new Student();
System.out.println(person instanceof Student); // true
System.out.println(person instanceof Person); // true
System.out.println(person instanceof Object); // true
System.out.println(person instanceof Teacher); // false
// System.out.println(person instanceof String); // 编译报错
System.out.println("=================================");
Student student = new Student();
System.out.println(student instanceof Student); // true
System.out.println(student instanceof Person); // true
System.out.println(student instanceof Object); // true
// System.out.println(student instanceof Teacher); // 编译报错
// System.out.println(student instanceof String); // 编译报错
}
}
类型转换
package oop;
import oop.demo08.Person;
import oop.demo08.Student;
public class Test {
public static void main(String[] args) {
/*
* 1.父类引用指向子类的对象；
* 2.把子类转换为父类，向上转型，可自动转换；
* 低--》高(子类--》父类) eg: SuperClass superObj = subObj;
* 3.把父类转换为子类，向下转型，强制转换；
* 高--》低(父类--》子类) eg: (SubClass) superObj
* */
// 类型之间的转换： 父 子
System.out.println("=======================");
Person obj = new Student(); // Student 类型 转为 Person 类型， 为 子--》父， 自动转换
// obj.go(); // 编译报错, obj 为 Person类型，不能调用 子类Student 的 go方法
((Student) obj).go(); // 强制类型转换为 Student
System.out.println("=======================");
// 低--》高(子类--》父类) 可以自动转换， 但会丢失一些自己本来的方法
Student s = new Student();
s.go();
Person p = s; // s 为 Student 类型， 自动转换为 Person 类型
// p.go(); // 丢失了 go方法， 编译报错
p.run();
}
}
匿名对象
匿名对象就是定义一个没有名称的对象 该对象特点是只能使用一次，该对象会直接在堆中开辟内存空间 该对象使用后会成为垃圾对象，被GC回收
new 类名("").方法名(); //生成匿名对象,只能使用一次
匿名对象特点:
// 对方法或字段只进行一次调用
new Car().show();
new Car().run();
// 可作为实际参数进行传递，只在堆内存中开辟空间，而没有在栈内存的引用
public void show(Car c){ }
new Car().show(new Car());
this关键字
this关键字特点：this表示当前对象。 调用类中的属性、调用类中的方法或构造方法、表示当前对象 当前对象 ←→ 当前正在调用实例成员的对象 换言之：谁调用了方法，谁就是当前对象。
什么时候使用this关键字呢？
- 方法间的相互调用;
- this.字段；
- 构造器中相互调用，但是此时this([参数])必须写在构造方法第一行；
- his不能用在static修饰的方法里和static修饰的代码块里；
import语句
JAVA包主要用来对类和接口进行分类 当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类 Import语句通俗的说就是引入或导入的意思 例如，下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类
import java.io.*; //*星号表示寻找某个包下被使用到的全部类
Java常用包介绍
java.lang // 语言核心类，系统自动导入
java.util // java 工具类、集合框架类和接口
java.net // 网络编程接口和类
java.io // 流的接口和类
java.text // java格式化相关类
java.sql // jdbc相关接口和类
java.awt // 抽象窗口工具集相关接口和类
java.swing // 图形用户界面相关接口和类(可跨平台)