Java面向对象(01)--初识
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 + "\t" + s1.age);
s1.name = "panky";
s1.age = 27;
System.out.println(s1.name + "\t" + 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 // 图形用户界面相关接口和类(可跨平台)