在jvm内存中主要分布有以下三个区域:
栈:存放基础数据和自定义对象的引用
堆:主要存储创建的对象,即new出来的对象
方法区:加载存放class文件(字节码文件)
什么是封装?
封装是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
封装的优点:
隐藏代码的实现细节,提高安全性。
private 私有属性:(调用属性先执行提供的get或set方法)
私有属性:
class Person {
//姓名
private String name;
//年龄
private int age;
//对外提供公共的访问方式,编写set和get方法
public void setAge(int _age){
if(_age>0 && _age < 120){
age = _age;
}else{
System.out.println("年龄不符合常理,请重新设置!");
}
}
public int getAge(){
return age;
}
public void setName(String _name){
name = _name;
}
public String getName(){
return name;
}
}
View Code
**基本数据类型的参数传递,值传递:(值不会受到影响)
**
/*
基本数据类型的参数传递,值传递
*/
public class ParamTest01{
public static void m1(int i){
i = i + 1;
System.out.println("m1方法中的i=" + i);//11
}
public static void main(String[] args){
int i = 10;
m1(i);
System.out.println("main方法中的i=" + i);//10
}
}
引用数据类型传递,传递的是引用传递(值会改变)
/*
引用数据类型的参数传递,传递的引用,引用传递
*/
public class AnimalTest01 {
public static void m1(Animal a){
int age = a.getAge();
a.setAge(++age);
System.out.println("m1方法中的age=" + a.getAge());//11
}
public static void main(String[] args) {
Animal a = new Animal();
a.setAge(10);
m1(a);
System.out.println("main方法中的age=" + a.getAge());//11
}
}
构造方法:
对象被创建时会执行
构造方法(constructor),有的地方叫做构造器或者构造函数。
构造方法的作用是给对象数据进行初始化。
构造方法格式特点
1.方法名与类名相同(注意大小写也要与类名一致)
2.没有返回值类型
3.没有void修饰
4.没有具体的返回值return;
5.如果一个类没有提供任何构造方法,系统默认提供无参数构造方法
6.如果一个类已经手动的提供了构造方法,那么系统不会再提供任何构造方法。
定义构造方法
class User{
private String name;
private int age;
//构造方法,最好手动编写一个无参的构造方法
public User(){
System.out.println("构造方法");
}
public User(String _name, int _age){
name = _name;
age = _age;
}
public String getName(){
return name;
}
public void setName(String _name){
name = _name;
}
public int getAge(){
return age;
}
public void setAge(int _age){
age = _age;
}
}
View Code
调用
public class UserTest01 {
public static void main(String[] args) {
User u = new User();
//u.User();不能手动调用构造方法
/*
User u = new User("赵六",20);
System.out.println(u.getName());
System.out.println(u.getAge());
*/
}
}
View Code
通过this 关键字(指代当前类) 实例对象调时 值显示对象传入的值 (注意:java中就存在近原则)
实例 View Code
static(修饰类的变量,和对象没有关系)
可以修饰变量,被static修饰的变量叫做静态变量,
程序运行时静态变量存放在方法区里面,因此,静态变量在类加载阶段赋值,并且只赋值一次。
class Employee{
private String name;
static String company = "阿里巴巴";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class StaticTest01 {
public static void main(String[] args){
Employee e = new Employee();
System.out.println(e.company);//开发中不建议这样使用
e = null;
System.out.println(e.company);//不报错,static修饰的变量跟对象没有关系
System.out.println(Employee.company);//开发中建议这样写,使用类名.静态变量名的方式访问静态变量
}
}
View Code
static可以修饰方法,被static修饰的方法叫做静态方法,(修饰方法,和对象没有关系)
不用创建对象就能能直接访问该方法,即使用类名.静态方法名的方式。
静态方法不能访问非静态的数据(调用非静态方法也不可以),静态方法不能使用this。
public class StaticTest02{
int i;
public void m1(){
System.out.println("m1方法");
}
public static void m2(){
//m1();//error静态方法不能引用非静态方法
//System.out.println(i);//error静态方法不能引用非静态变量
System.out.println("静态方法m2");
}
public static void main(String[] args){
StaticTest02 st = new StaticTest02();
st.m1();
m2();//静态方法可以直接调用静态方法
StaticTest02.m2();//开发中建议这样使用
st = null;
st.m2();//开发中不建议这样使用,静态方法跟对象无关
}
}
View Code
static可以定义静态语句块,静态语句块在类加载阶段执行,并且只执行一次,并且是自上而下的顺序执行,在构造方法之前执行。
public class StaticTest03{
//静态语句块中的内容只会执行一次
static{
System.out.println("静态语句块1");
}
static{
System.out.println("静态语句块2");
}
static{
System.out.println("静态语句块3");
}
public StaticTest03(){
System.out.println("构造方法");
}
public static void main(String[] args){
System.out.println("main方法1");
System.out.println("main方法2");
new StaticTest03();
new StaticTest03();
}
}
View Code
代码块
局部代码块,在方法中出现,限定变量生命周期,及早释放,提高内存利用率
构造代码块,在类中方法外出现;多个构造方法方法中相同的代码存放到一起,每次调用构造都执行,并且在构造方法前执行
静态代码块, 在类中方法外出现,并加上static修饰;用于给类进行初始化,在加载的时候就执行,并且只执行一次。一般用于加载驱动。
同步代码块(后面多线程部分会讲解)
public class BlockTest01 {
public static void main(String[] args) {
//局部代码块
{
int x = 10;
System.out.println(x);
}
//System.out.println(x);
Student s1 = new Student();
System.out.println("------------");
Student s2 = new Student();
}
static{
System.out.println("BlockTest01中的静态代码块");
}
}
class Student {
public Student(){
System.out.println("构造方法");
}
//构造代码块
{
System.out.println("构造代码块");
}
static{
System.out.println("静态代码块");
}
View Code
先执行静态代码块 局部代码块 构造代码 构造方法
继承:extends
子类不能访问父类中private修饰的方法
public class Test01 {
public static void main(String[] args) {
SubClass s = new SubClass();
s.m1();
//s.m2();//error子类不能访问父类中private修饰的方法
s.m3();
s.m0();//子类可以访问到其祖先类的方法
}
}
重写****,也叫做覆盖,当父类中的方法无法满足子类需求时,子类可以将父类的方法进行重写编写来满足需求。比如孩子继承了父亲的房子,可以将房子重新装修。
方法重写的条件:
- 两个类必须是继承关系
- 必须具有相同的方法名,相同的返回值类型,相同的参数列表.
- 重写的方法不能比被重写的方法拥有更低的访问权限。
- 重写的方法不能比被重写的方法抛出更宽泛的异常。
- 私有的方法不能被重写。
- 构造方法无法被重写,因为构造方法无法被继承。
- 静态的方法不存在重写。
- 重写指的是成员方法,和成员变量无关。
super 关键字 调用父类方法 或 变量
public class Dog extends Animal {
public String name = "旺财";
public void eat(){
System.out.println("吃狗粮");
}
public Dog(){
//super("土豪金","藏獒");super()
System.out.println("Dog中的无参构造方法");
}
public void m1(){
System.out.println(super.name);
System.out.println(this.name);//可以不加this
super.eat();
this.eat();//可以不加this
}
}
多态: 不同实例调用相同方法时返回值却不相同
public class AnimalTest01 {
public static void main(String[] args) {
Cat c1 = new Cat();
c1.eat();
Animal a1 = new Cat();//父类引用指向子类对象,自动类型转换,也叫做向上转型
a1.eat();//动态绑定和静态绑定
//System.out.println(a1.num);//结果10,说明成员变量不存在重写
//a1.move();
Cat c2 = (Cat)a1;//强制类型转换,也叫做向下转型
c2.move();
Animal a2 = new Dog();
if(a2 instanceof Cat){
Cat c4 = (Cat)a2;
}else{
System.out.println("a2不是Cat类型");
}
//Cat c3 = (Cat)a2;//error ClassCastException类转型错误
}
}
View Code
成员变量不存在重写
final:
final修饰的类无法被继承。
final修饰的方法无法被重写。
final修饰的局部变量,一旦赋值,不可再改变。
final修饰的成员变量必须初始化值。
public class FinalTest01{
public final int k = 10;
//常量,标识符大写
public static final double PI = 3.14;
public static void main(String[] args){
/*
final int i = 10;
i = 20;
*/
}
}
final修饰的基本数据类型,值不能改变
final修饰的引用数据类型,指向地址是不能改变的,但是对象里面的值是可以改变的
抽象类:abstract
public abstract class A{
public A(){
System.out.println("class A");
}
//抽象方法
public abstract void m1();
public static void main(String[] args){
//A a = new A();//抽象类不能被实例化
A a = new B();
a.m1();
}
}
class B extends A{
public void m1(){
System.out.println("class B中的m1方法");
}
public B(){
super();
System.out.println("class B");
}
}