目录
1.面向对象——能进行现实生活的抽象
世界是由一系列对象互相组合形成(多个对象之间的相互协作),每个对象有自己的属性和方法。
面向对象:即对现实事物进行的抽象,把具有共同特点的东西抽象为一个类
通俗解释:狗吃粮,狗和粮是两个对象 ,吃是行为
每个对象——类,每个类有自己的属性及方法
2.新兴的编程范式
面向切面编程:EE-AOP
面向接口编程——接口优先原则
函数式编程:Scala(JVM)
3.面向对象名字扩展
4.面向对象三大特征
a.封装性:内部操作对外部而言不可见,强调保护性
b.继承性:对现有类在无需重新编写原来的类的情况下,进行功能上的扩展。
c.多态性:一个类实例的相同方法在不同情形下有不同的表现形式。好处:使得具有不同内部结构的对象可以共享相同的外部接口。(利用多态可以得到良好的设计)
5.类与对象的定义与使用
class 类名称 {
属性1;
属性2;
属性n...;
方法1(){}
方法2(){}
方法n(){}...
}
- 类是共性的概念;对象是一个具体的、可以使用的事物。
- 类的组成:
- 先有类才可以产生对象。对象的所有属性与行为,一定在类中进行了完整定义。
- 类中的属性与方法(不带static关键字的)只能通过对象调用
- 类的设计原则:编写类时,没有额外说明,所有属性必须使用private封装(成员变量)
- 类定义顺序:
定义属性 -> 定义构造方法 -> 定义普通方法
-
5.1 对象的产生
对象在主方法中产生
- 产生语法:
类名称 对象名称 = new 类名称
- 开辟内存空间
- 初始化成员变量
- 调用默认构造器
- 把堆中的对象赋给栈中的引用
-
对象(引用数据类型)必须在实例化后调用,否则会产生 NullPointerException (运行时错误),编译时不会出错。
/**
* 将人抽象为一个类
* Author: qqy
*/
public class Person {
//属性
private String gender;
private int age;
private String name;
private int height;
public static void main(String[] args) {
//对象
Person person=new Person();
person.gender="女";
person.age=10;
person.name="张三";
person.height=60;
person.movie();
person.music();
}
//行为
public static void movie(){
System.out.println("看电影");
}
public static void music(){
System.out.println("听音乐");
}
}
-
5.2 对象内存分析
先简单的将Java中的内存区域分为栈内存和堆内存两块区域
栈内存(虚拟机局部变量表):存放的是局部变量(各种基本数据类型 / 对象引用-对象名字)
堆内存:保存对象(new表示在堆上新分配空间)
垃圾空间:没有任何栈内存指向的堆内存空间
6.构造方法
- 抽象出一个类,如果没有明确定义,系统会自动生成无参构造;若在类中自定义了构造方法,则系统不会自动生成无参构造。
- 默认的构造方法:
public 类名(){
}
- 意义:类中属性初始化
1Person 2person = 3new 4Person();
1类名:通过哪个类产生对象
2产生的对象名,引用一块堆内存
3开辟一块堆内存
4构造方法
public class Person1{
String name;
int age;
private String secret ="xxxxx";
//构造方法
//方法名与类名一样
//返回值:无
public Person1(){
}
public Person1(String name,int age){
//我的name等于你给赋值的name
this.name=name;
this.age=age;
}
String personInfo(){
return "这个人叫"+name+",年龄"+age;
}
String getSecret(){
return secret +"!!";
}
//具体对象
public static void main(String[] args){
//对象1
Person1 person = new Person1();//创建对象
//对对象的属性进行赋值
person.name="Jack";
person.age=21;
//对象2
Person1 person1=new Person1("张三",23);
//引用传递
//peron对象引用的地址赋值给person2
Person1 person2 = person;
person2.age=25; //person的age也改变
//person变量引用指向空
//person = null;
//person4 = null;
//堆上的person对象已经没有 变量 使用它(引用)
//但是person对象依然存在,不做内存回收,JVM自动回收
//调用对象的行为(方法)
System.out.println(person.personInfo());
System.out.println(person1.personInfo());
System.out.println(person2.personInfo());
System.out.println(person.getSecret());
}
}
疑问:
Person person;
Person person=null;
上述两种表达有何不同???
解答:
第一种只是声明,没有初始化,无法通过编译;第二种是将person初始化为null,运行时可能会出现空指针异常。
-
三大特征:
a.构造方法名称必须与类名称相同
b.构造方法没有返回值类型声明(构造本身有返回值,返回当前构造的对象)
c.每个类中一定至少存在一个构造方法。
- 属性、构造方法、普通方法
属性是在对象开辟堆内存时开辟的空间
构造方法是在使用new后调用的
普通方法是在开辟了空间、执行构造方法之后可以多次调用的
- 构造方法重载:参数个数不同,可以创建出不同属性信息的对象
- 匿名对象:
new Person("张三",20).getPersonInfo();
由于匿名对象不会有任何的栈空间所指向,所以使用一次后就成为垃圾空间。
7.this关键字
a.表示调用属性
只要在类中访问类的属性,一定要加上this关键字
b.表示调用本类方法
(1)调用普通方法 this.方法名(参数)
当有类的继承关系时,表示本类方法一定要加上this关键字。否则,可加可不加。
(2)调用构造方法 this(参数)
this调用构造方法必须放在构造方法首行;this调用构造方法不允许成环,以便留有出口
c.表示当前对象
只要对象调用了本类中的方法,这个this就表示当前执行的对象
打印对象时,生成的是类的类型+hashcode(java在内部对每一个对象做一个编码,表示其唯一性)
代码示例:
/**
* this关键字
* Author:qqy
*/
public class OOP {
String gender;
String name;
int age;
public void setGender(String gender) {
this.gender = gender;
}
public OOP() {
System.out.println("无参构造方法");
}
public OOP(String name, int age) {
//this调用本类无参构造
this();
//this调用本类属性
this.name = name;
this.age = age;
}
public OOP(String name,int age,String gender){
//this调用本类有参构造
this(name,age);
this.gender=gender;
//this调用普通方法
this.print();
}
String personInfo() {
return "这个人叫" + name + "年龄" + age+"性别"+gender;
}
public void print() {
System.out.println("*****************");
}
public void print1() {
//this表示当前对象
System.out.println("print " + this);
}
public static void main(String[] args) {
OOP per1 = new OOP();
per1.name = "Tom";
per1.age = 18;
OOP per2 = new OOP("Mary",25);
per2.setGender("女");
OOP per3 = new OOP("Alice", 22,"女");
System.out.println(per1.personInfo()); //这个人叫Tom年龄18性别null
System.out.println(per2.personInfo()); //这个人叫Mary年龄20性别女
System.out.println(per3.personInfo()); // 这个人叫Alice年龄22性别女
per1.print1(); //print com.qqy.oop.OOP@1540e19d
}
}
8.private实现封装
将属性、方法用private封装后表示,被封装的属性与方法只能在本类中使用,类外部不可见。此时想要访问被封装的属性,必须提供getter和setter方法。
- setter方法:主要进行属性内容的设置与修改
-
getter方法:主要进行属性内容的取得
- 当类中有一个属性不希望被外部访问或修改,则不需写setter方法
- private可以用于内部类的封装,但是不能用于外部类的封装
代码示例:
public class OOP{
private String name;
private int age;
private String secret="***";
private String hobby;
//假设创建对象时必须同时赋予名字,因此,不提供无参的构造方法
//有参的构造方法
public OOP(String name){
this.name=name; //对象的名字=赋值的名字
}
//方法、行为
public String personInfo(){
return "这个人叫"+name+",年龄是"+age+",爱好是"+hobby;
}
//getter getXXX() XXX为属性名称
String getName(){
return name;
}
int getAge(){
return age;
}
String getSecret(){
return secret;
}
String getHobby(){
return hobby;
}
//setter setXXX() XXX为属性名称
void setAge(int age){
this.age=age;
}
void setHobby(String hobby){
this.hobby=hobby;
}
}
public class OOPTest{
public static void main(String [] args){
//对象1
//创建对象
//假设姓名不得修改,因此不提供setName()方法
OOP per1=new OOP("Tom");
// 对属性赋值
per1.setAge(20);
per1.setHobby("跑步");
//OOP类的保护——封装
//外部程序要访问 封装的属性 通过提供的getter方法访问
System.out.println(per1.getSecret());
System.out.println(per1.personInfo());
}
}
9.static关键字
-
9.1 static类属性
static属性又称为类属性(静态属性),保存在全局数据区中(方法区——所有对象共享区域),通过类名直接调用,与对象实例化无关。
代码示例:
/**
* static属性
* Author:qqy
*/
public class Test {
public static void main(String[] args) {
Person3 p1 = new Person3();
p1.name = "张三";
p1.age = 10;
Person3 p2 = new Person3();
p2.name = "李四";
p2.age = 20;
p1.getPersonInfo();
p2.getPersonInfo();
}
}
class Person3 {
String country = "中国";
String name;
int age;
public void getPersonInfo() {
System.out.println("姓名:" + this.name + ",年龄:" + this.age + ",国家:" + this.country);
}
}
内存分析图:
将上述代码改为:
class Person3 {
//类属性(静态属性)
static String country = "中国";
String name;
int age;
public void getPersonInfo() {
System.out.println("姓名:" + this.name + ",年龄:" + this.age + ",国家:" + Person3.country);
}
}
则内存分析图:
- static属性(类属性)不受对象实例化控制,而所有的非static属性(实例变量)必须在对象实例化后使用,
- 定义类时,如何选择实例变量和类属性?
在定义类时,以非static属性(即实例变量)为主;需要描述共享属性的概念,或不受对象实例化控制,使用static
-
9.2 static类方法
使用static定义的方法,直接通过类名调用。与对象实例化无关,广泛存在于工具类中。
-
所有的static方法不允许直接调用非static定义的属性或方法,只能 1.在静态方法中new一个对象,通过对象调用 2.给静态方法中的参数传一个对象;
/**
* 静态调用非静态
* Author:qqy
*/
public class Test1 {
static int i;
int b;
public static void main(String[] args) {
}
public void eat(){
System.out.println("chi"+i+b);
}
//1.
public static void drink(){
Test1 t=new Test1();
t.eat();
System.out.println("he"+i+t.b);
}
public static void drink(Test1 t){
t.eat();
System.out.println(i+t.b);
}
}
-
所有的非static方法允许访问static方法或属性
-
局部变量不能用static修饰(对于方法中的变量不能用static修饰)
- static不能加在外部类之上,内部类可以
- main( )方法是程序的入口。因为main( ) 方法是静态方法,不受对象的控制,可以被调用,调用的时候不需要面向对象。
-
调用静态的属性和方法,建议加上类名—— 类名. 属性名 类名. 方法名