通过
对象.属性
或对象.方法
调用对象的结构。
注意:存放在Heap内的属性都是非static,static的都存放到方法区,因此方法区也叫静态区。
大体过程如下:
public class HelloWorld {
public static void main(String[] args) {
Student[] stus = new Student[5];
stus[0] = new Student();
System.out.println(stus[0]); //声明定义后得到的是地址
System.out.println(stus[1]); //没有定义为null
}
}
class Student{
int number;
int state = 1;
int score;
}
对象数组的内存解析:
public class HelloWorld {
public static void main(String[] args) {
Phone p = new Phone();
System.out.println§;
p.sendEmail();
p.playGame(“lol”);
//匿名对象 ,就是没有名字的调用 ,注意这里两个new不是相同的!
new Phone().playGame(“英雄联盟1”);;
new Phone().playGame(“英雄联盟2”);
//匿名对象特点就是只能调用一次。
}
}
class Phone{
double price;
public void sendEmail() {
System.out.println(“发送邮件”);
}
public void playGame(String s) {
System.out.println("玩游戏 " + s);
}
}
定义: 在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。
·
记住对于方法重载一定看参数个数和类型,和对应返回值什么的无关!!
package com.holmes.contact;
public class ArrayUtil {
//一个参数
public int OverLoad(int i) {
return i;
}
//没有参数
public double OverLoad() {
return 0;
}
}
package com.holmes.contact;
import java.util.Arrays;
public class ArrayUtil {
public static void main(String[] args) {
ArrayUtil arr = new ArrayUtil();
arr.show(“1”,“2”,“3”);
}
//使用…接受不确定参数,像一个数组形参
public void show(String… str) {
System.out.println(Arrays.toString(str));
}
}
正常值传递,就像下面调用了函数swap,也并没有交换数值。可以理解为仅仅只是交换了形参,没有交换实参,实际上就是一个栈的先进先出的问题。
package com.holmes.contact;
import java.util.Arrays;
public class ArrayUtil {
public static void main(String[] args) {
int m = 11;
int n = 22;
ArrayUtil arr = new ArrayUtil();
System.out.println("m = “+ m +”, n = "+ n);
arr.swap(m,n);
System.out.println("m = “+ m +”, n = "+ n);
}
//使用…接受不确定参数,像一个数组形参
public void swap(int m,int n) {
int temp = m;
m = n;
n = temp;
}
}
//m = 11, n = 22
//m = 11, n = 22
对象值传递,要注意的是对象是地址,正常数值是重新赋值(新地址)。因此,直接操作对象地址就是修改实参对象本身
package com.holmes.contact;
public class Test {
public static void main(String[] args) {
Test arr = new Test();
arr.first();
//这里注意的就是对象的值传递是传递的地址,因此在函数修改会修改对象的值。
//15 0
//20
}
public void first() {
int i=5;
Value v = new Value();
v.i = 25;
second(v,i);
System.out.println(v.i);
}
public void second(Value v,int i) {
i = 0;
v.i = 20;
Value val = new Value();
v = val;
System.out.println(v.i + " " + i);
}
}
class Value{
int i = 15;
}
那么如何想要正常值在被执行调用函数后,想要它的执行结果是函数的值呢?
方法一:
使用System.exit(0)退出程序。
package com.holmes.contact;
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 10;
//这我像调用了method方法后,结果输出a的值为100,b的值为200.
method(a,b);
System.out.println("a = "+a);
System.out.println("b = "+b);
}
public static void method(int a,int b) {
a *= 10;
b *= 20;
System.out.println("a = "+a);
System.out.println("b = "+b);
System.exit(0);
}
}
方法二:
重写println方法。
package com.holmes.contact;
import java.io.PrintStream;
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 10;
//这我像调用了method方法后,结果输出a的值为100,b的值为200.
method(a,b);
System.out.println("a = "+a);
System.out.println("b = "+b);
//a = 100
//b = 200
}
public static void method(int a,int b) {
PrintStream ps = new PrintStream(System.out) {
@Override
public void println(String x) {
if(“a = 10”.equals(x)) {
x = “a = 100”;
}else if(“b = 10”.equals(x)){
x = “b = 200”;
}
super.println(x);
}
};
System.setOut(ps);
}
}
就是在函数中调用本身,依次递归的方法。
注意的是:有个别的可以做if判断。
package com.holmes.contact;
import java.io.PrintStream;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
System.out.println(f(10));
}
public static int f(int i) {
if(i == 0) {
return 1;
}else if(i == 1) {
return 4;
}else {
return 2*f(i-1)+f(i-2);
}
}
}
==========================================================================
面向对象三大特征:封装,继承,多态。
封装就是一个隐藏效果,封装好直接用的方法或者类。
四个访问修饰符:
为了封装效果,我们常常通过getxxx()和setxxx()来获取和设定属性值。
======================================================================================
package com.holmes.contact;
public class Test {
public static void main(String[] args) {
Person p = new Person();
Person p1 = new Person(1,2);
Person p2 = new Person(“ab”,“cd”);
p.GetAbs();
p1.GetAbs();
p2.GetAbs();
}
}
class Person{
int a;
int b;
String str1 = “0”;
String str2 = “0”;
//以下就创建了几个不同参数和类型的构造器
public Person() {
this.a = 0;
this.b = 0;
}
public Person(int a,int b) {
this.a = a;
this.b = b;
}
public Person(String str1,String str2) {
this.str1 = str1;
this.str2 = str2;
}
public void GetAbs() {
System.out.println(a+“,”+b+“,”+str1+“,”+str2);
}
}
============================================================================
======================================================================
========================================================================
this最常用的作用就是区别形参和属性,不能混淆。
当然this也可以应用到调用函数中,其实this就可以理解为本类中的内容。
像this(),其实就是调用类本身的构造器(注意:在构造器中不能调用本身的构造器,可以调用其他构造器),也可以加参数。
package com.holmes.contact;
public class Test {
public static void main(String[] args) {
Person p = new Person();
p.eat();
}
}
class Person{
int a;
int b;
public Person() {
this.a = 0;
this.b = 0;
}
public void eat() {
System.out.println(“吃饭”);
//this应用到方法
this.play();
}
public void play() {
System.out.println(“玩游戏”);
}
}
=================================================================================
Package就是包。
import导入:
注意:import导入的不是一个类!是类中的结构(方法,接口等等)。
全类名命名方式:
=========================================================================
============================================================================
==========================================================================
面向对象三大特征:封装,继承,多态。
一旦子类A继承了父类B以后,子类A就获取了父类B种声明的结构,属性,方法。
特别的,父类中声明为private的属性或方法,子类继承后,仍然认为获取了父类中私有的结构,但是因为封装性的影响,使得子类不可以直接调用父类的private结构而已!!!
子类继承父类以后,还可以声明自己特有的属性或方法,来实现别的功能。
如果我们没有显示声明一个类的父类的花,则此类默认继承了java.lang.Object类。
所有的java类(除java.lang.Object类之外),都直接或间接的继承了java.lang.Object类!
也就是说,所有的java类具有java.lang.Object类声明的功能!!
==========================================================================
Debug通常遇到,没有报错,但是结果却是错误的。
设置多个断点
debug as java application
以下几个按钮对应上面的几个操作:
====================================================================
方法重写(override / overwrite):子类继承父类以后,可以对父类中同名同参数的方法,进行覆盖操作。
子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符!
特殊情况:子类不能重写父类中声明为private权限的方法!!
返回值类型:
父类被重写的方法的返回值类型是void,则子类重写的方法返回值类型只能是void!!!
父类被重写的方法的返回值类型是A类型,则子类重写的方法的返回值类型可以是A类或A类的子类。
父类被重写的方法的返回值类型是基本数据类型,则子类重写的方法的返回值类型必须是相同的基本数据类型。!
==========================================================================
如果this指的当前类,那么super就指的是父类。
super调用父类属性和方法:
super调用构造器:
=========================================================================
父类的引用指向了子类的对象!!
**虚拟方法调用:
当调用子父类同名同参数的方法时,实际执行的是子类重写父类的方法。**
package com.itholmes.p2;
public class PersonTest {
public static void main(String[] args) {
//定义了Person类调用
Person p1 = new Person();
p1.eat();
//定义了Man类调用
Man man = new Man();
man.eat();
man.age = 25;
//定义了Woman类调用
Woman woman = new Woman();
woman.eat();
System.out.println(“******************”);
//对象多态形式:父类的引用指向子类的对象
Person p2 = new Man();
//当调用子父类同名同参数的方法时,实际执行的是子类重写父类的方法。–虚拟方法调用
p2.eat();
p2.walk();
//earnMoney()没有在父类Person中定义,在子类Man中定义了。
//p2中的earnMoney()方法就不能被调用了,因为Person中没有!!!
//p2.earnMoney();
}
}
多态性常用的情形:
package com.itholmes.p2;
public class Test {
public static void main(String[] args) {
Test t = new Test();
//多态性操作
t.func(new Dog());
}
//设置类对象为接受
public void func(Animal animal) {
animal.eat();
animal.shout();
}
}
class Animal{
public void eat() {
System.out.println(“动物吃饭”);
}
public void shout() {
System.out.println(“动物手套”);
}
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println(“小狗吃饭”);
}
@Override
public void shout() {
System.out.println(“小狗手套”);
}
}
对象的多态性,只适用于方法,不适用于属性! 我们如果定义了在子类和父类中定义了相同属性,调取时也仅仅调用了父类,也就是对于属性(编译和运行都看左边)。
package com.itholmes.p2;
public class Test {
public static void main(String[] args) {
Animal animal = new Dog();
//运行也仅仅显示的是父类
System.out.println(animal.age);
}
}
class Animal{
int age = 10;
}
class Dog extends Animal{
int age = 20;
}
**多态仅仅能够调用父类的方法和属性和子类重写的方法,
那么,如何调用子类特有的属性和方法?**
向下转型:使用强制类型转换符号!!
package com.itholmes.p2;
public class Test {
public static void main(String[] args) {
Animal animal = new Dog();
//对于属性运行也仅仅显示的是父类属性
System.out.println(animal.age);
//向下转型,强制转换
Dog d = (Dog)animal;
System.out.println(d.age);
}
}
class Animal{
int age = 10;
}
class Dog extends Animal{
int age = 20;
}
================================================================================
instanceof操作符:
package com.itholmes.p2;
public class Test {
public static void main(String[] args) {
Animal animal = new Dog();
//对于属性运行也仅仅显示的是父类属性
System.out.println(animal.age);
//向下转型,强制转换
Dog d = (Dog)animal;
System.out.println(d.age);
//这个时候的animal已经转为了Dog类型!!!
System.out.println(animal instanceof Dog);
//10
//20
//true
}
}
class Animal{
int age = 10;
}
class Dog extends Animal{
int age = 20;
}
class monkey extends Animal{
int age = 30;
}
alt + shift + s 快捷键,弹出源代码的相关选项,通常用来获取变量的get和set,构造器的方法。
============================================================================
Object类是所有Java类的根父类。
如果在类的声明中未使用extends关键字指明其父类,则默认父类为java.lang.Object类。
getClass() :获取当前类名
getSuperclass() :获取当前父类名
package com.itholmes.p2;
public class Test {
public static void main(String[] args) {
Order order = new Order();
//getClass()获取当前类名
System.out.println(order.getClass());
//getSuperclass()获取当前父类名
System.out.println(order.getClass().getSuperclass());
//class com.itholmes.p2.Order
//class java.lang.Object
}
}
class Order{
}
Object类中的clone()方法:复制类。
==================================================================================
== 作用:
比较基本数据变量数据是否相同。
比较引用数据类型变量,对象地址值是否相同。
equals()方法使用:
只能适用于引用数据类型。
========================================================================================
注意和之前的Arrays.toString()方法不同!
一般我们定义的类:返回类的路径和类名 + @ + JVM虚拟地址。
像Integer这种包装类,使用toString()后,得到的是对应的基本数据类型(例如Integer对应int)。
package com.itholmes.p2;
public class test {
public static void main(String[] args) {
Tom t = new Tom();
//当我们输出一个对象的引用时,实际上就是调用当前对象的toString()方法。
System.out.println(t.toString());//com.itholmes.p2.Tom@5aaa6d82
System.out.println(t);//com.itholmes.p2.Tom@5aaa6d82
}
}
class Tom{
}
像toString这种方法完全可以ctrl + 左键 ,查看他的源码!
==============================================================================
注意权限public,没有返回值,没有形参。
package com.itholmes.p2;
import java.util.Date;
import org.junit.Test;
public class test {
@Test
public void testEquals() {
String s1 = “MM”;
String s2 = “MM”;
System.out.println(s1.equals(s2));
Object obj = new String(“GG”);
Date date = (Date)obj;
}
}
手动导入方法如下:
==============================================================================
三者转换:基本数据类型,包装类,String。
20.1 类的基本数据类型 ⇒ 转换为包装类(通过,调用包装类的构造器)
integer类型转换注意事项:
package com.itholmes.p2;
import org.junit.Test;
public class test {
//类的基本数据类型 ==》 转换为包装类(通过,调用包装类的构造器)
@Test
public void testEquals() {
int num1 = 0;
//基本数据类型变量无法直接使用toString类的方法
//System.out.println(num1.toString());
//但是如果是类对象转换就可以使用类方法。
Integer in1 = new Integer(num1);
System.out.println(in1.toString());
//符合integer型的字符串形式可以
Integer in2 = new Integer(“123”);
System.out.println(in2.toString());
//但是,不符合就会报错!!!
// Integer in3 = new Integer(“123abc”);
// System.out.println(in3.toString());
}
}
boolean类型转换注意事项:
package com.itholmes.p2;