目录
对象与引用
1.Java中,除基本类型外的变量类型都称之为引用类型;
2.Java中的对象是通过引用对其操作的;
3.以Car bm = new Car();为例:是以Car类为模板,在堆空间里创建一个Car类对象;左边的Car bm创建了一个Car类型的引用变量(以后可以用来指向Car对象的对象引用)“=”操作符使对象引用指向刚创建的那个Car对象;Car bm;bm=new Car;拆成两部分理解,一是对象引用变量,一是对象本身;
解释说明:
值传递与引用传递
值传递
值传递:基本类型作为参数;
public class TestValue {
public void test(int x){
x = 20;//变量x值发生变化,与a没有任何关系
}
public static void main(String[] args) {
TestValue t = new TestValue();
int a = 10;
t.test(a);//传递的是基本类型,可是用a的值实际填充了x, 是两个不相干的变量
System.out.println(a);//10
}
}
引用传递
引用传递:本质上也是值传递,只是为了和基本类型区分,称为引用地址传递;
public class TestRef {
public void test(Person p){//p = p1 = (地址) 指向的是同一个对象
p.name = "李四";
}
public static void main(String[] args) {
TestRef t = new TestRef();
Person p1 = new Person(); //p1=(地址)
p1.name = "张三";
p1.age = 20;
t.test(p1);//对于引用类型,只是将对象的引用地址值传递
System.out.println(p1.name);//李四
}
}
this关键字
1.this关键字代表当前对象;
2.使用this关键字引用成员变量;
3.使用this关键字引用成员方法;
static关键字
1.static 静态,修饰类的属性,方法,代码块,内部类;
2.随着类的加载而加载;
3.优先于对象存在;
4.修饰的成员,被所有对象所共享;
5.可不创建对象,直接被类调用;
作用:优化内存空间;
修饰成员变量
被static修饰的成员变量,成员方法可以被类调用,属于类,只有一个;
/*
中国人类
*/
public class Chinese {
String name ;//姓名 每个人姓名都不一样, 没创建一个对象,对象中就会有一个name属性
//所有对象都一样的成员变量,可以修饰为static,称为类变量,随着类的加载而加载
static String country="中国";//国家, 每个对象中也都有一个country,就是一个静态变量(类变量)
}
修饰成员方法
/*
中国人类
*/
public class Chinese {
String name ;//姓名 每个人姓名都不一样, 没创建一个对象,对象中就会有一个name属性
//所有对象都一样的成员变量,可以修饰为static,称为类变量,随着类的加载而加载
static String country="中国";//国家, 每个对象中也都有一个country,就是一个静态变量(类变量)
/*
static修饰的方法,也被称为类方法,通过类名访问,也是随着类的加载而加载.
静态方法里面不能访问非静态,因为静态的先加载,非静态的随着对象创建而加载(初始化)
*/
public static void showCountry(){
System.out.println("国籍:"+country);
}
public void showInfo(){
System.out.println("姓名"+name+"国籍"+country);
}
}
public class TestChinese {
public static void main(String[] args) {
// Chinese.name; name是非静态的成员变量,属于对象,类不能直接访问,
//country被static修饰了,所有属于类,内存中只有一份,随着类加载而被加载初始化,建议使用类名访问静态
System.out.println(Chinese.country);
Chinese c1 = new Chinese();
System.out.println(c1.country);
//c1.country= "中国人";
Chinese.country = "中国人";
Chinese c2 = new Chinese();
System.out.println(c2.country);
c2.name = "jim";
c2.showInfo();
//Chinese c3 = new Chinese();
// c3.showCountry();
Chinese.showCountry();
}
}
静态的不能访问非静态的,非静态的可以访问非静态的;
代码块
代码块分为两种,在类中定义的代码块,没有名字;
实例代码块
没有被static修饰的代码块,在创建对象时会自动调用;
静态代码块
在类被加载时只调用一次;(默认认为一个类只被加载一次,一旦第一次加载后,就永远存在)
调用
满足条件后,自动调用;
public class Demo {
/*
代码块:两种,在类中定义的代码块,没有名字;
实例代码块:没有被static修饰的代码块,在创建对象时会自动调用;
静态代码块:在类被加载时只调用一次;(默认认为一个类只被加载一次,一旦第一次加载后,就永远存在)
调用:满足条件后,自动调用;
*/
{
System.out.println("实例代码块1");
}
{
System.out.println("实例代码块2");
}
static{
System.out.println("静态代码块1");
}
static{
System.out.println("静态代码块2");
}
public Demo(){
System.out.println("无参构造");
//实例代码块先于构造方法执行;
}
public static void test(){
}
public static void main(String[] args) {
//若把main方法写在Demo类里,静态代码块也会执行,因为Demo类被加载了;
}
}
注:实例代码块先于构造方法执行;
若把main方法写在Demo类里,静态代码块也会执行,因为Demo类被加载了;
public class TextDemo {
public static void main(String[] args) {
//类只被加载一次,问:什么时候会发生加载动作;创建对象的时候;调用类中的静态成员;
// Demo.test();//静态代码块执行,未创建对象,实例代码块不执行;
new Demo();//创建Demo类对象,先加载Demo类(加载静态成员),静态的先执行
// new Demo();//静态代码块执行一次,实例代码块执行两次;
}
}
类的加载与执行
类只被加载一次,什么时候会发生加载动作:创建对象的时候;调用类中的静态成员;
包
概念
为了更好的组织包装,Java提供了包机制,用于区别类名的命名空间,可以理解为一个文件夹;
类名 Car(简称)
类名==全类名==包名(类的地址)+类名;
作用
区分重名的类;
按照不同功能管理类;
控制访问权限;
命名规范
包名一般情况是小写,用“ . ”来区分包的等级;
第一级指该项目的类型,如com,org(开源组织),gov(政府)等;
第二级指项目所开发或者运行的公司名称,如: oracle,sun,huawei等;
第三级指项目的名称,如:bcms,oa,erp,cms等第四级指项目模块的名称,如:bean,action,exception等。
包可以更好得管逻辑相关的类,可以控制不同包之间的访问权限;
导入外部包的类,关键字“import";
package com.wm.javaoop.test;
/*
import 导入其他包中的类,在一个类中需要用到另一个包中的类时,需要先导入全类名;(导包)
*/
import com.wm.javaoop.day1.Demo;
public class Test{
public static void main(String[] args) {
new Demo();
/*
使用两个不同包里的类时,需要使用全类名;
*/
new com.wm.javaoop.day2.Demo();
/*
java.lang包下的类在使用时不需导入就可以使用;
*/
String s="abc";
}
}
注:import 导入其他包中的类,在一个类中需要用到另一个包中的类时,需要先导入全类名;(导包)
使用两个不同包里的类时,需要使用全类名;
java.lang包下的类在使用时不需导入就可以使用;(String)
访问权限修饰符
访问权限修饰符可修饰:成员变量、成员方法、构造方法、内部类。
public
公共权限修饰类、属性、方法。可以被任意类访问;
protected
受保护的权限修饰属性、方法;可以被同包类访问,如果不是同包类,必须是该类的子类才可以访问;
默认
同包权限 修饰类、属性、方法。只能被同包的类访问
private
私有权限 修饰属性、方法。 只能在本类中访问
package com.wm.javaoop.day1;
/*
public 修饰类时,类名必须与文件名一致;
一个.java文件中,只能有一个public 修饰的类;
*/
public class Demo {
public int pub;//公共权限 修饰类、属性、方法;任意类访问
protected int pro;//受保护权限 修饰属性、方法;同包类访问、不同包类的子类
int num;//默认权限(同包权限) 修饰类、属性、方法;同包类
private int pri;//私有权限 修饰属性、方法;只能在本类中访问
public void putMethod(){
}
protected void proMethod(){
}
void Method(){
}
private void priMethod(){
}
public static void main(String[] args) {
Demo demo=new Demo();
demo.pub=10;
demo.pro=20;
demo.num=30;
demo.pri=40;
}
}
面向对象特征
三大特征
封装 继承 多态
封装
指的是通过权限修饰符,使得类中的信息是否对外可见(隐藏类中的信息)
类的内部信息对外隐藏,将成员设置私有权限,对外提供特定的get set方法进行访问。
实现封装
- 通过修饰符修饰,进行属性私有化,private是封装的一种思想体现,其他修饰符也可以进行修饰。
- 对外提供方法入口:私有化后,外界无法直接访问,需对外界提供一个访问方式。提供特定方法(get set方法)来获取值和改变值。
this关键字
- this关键字指向的是当前类对象的引用
- 哪个对象调用this,this就指向哪个对象(就近原则)
- 用来区分成员变量和局部变量(重名问题)
设计模式:一系列解决问题的方案 算法
23种;
单例设计模式:解决只让一个类在一个程序中创建一个唯一的对象;
public class Person {
/*
使用private这个权限限制修饰符对成员变量进行修饰,在其他类中访问不到了;
*/
private String name;
private int age;
private static Person person=null;
/*
把构造方法设置私有权限;
*/
private Person(){
}
public static Person creatPerson(){
if(person==null){
person=new Person();
}
return person;
}
//为封装起来的成员变量提供一个特定的公共权限的方法,用来为其赋值;
//方便我们自己加入一些控制语句;
public void setName(String name){
if(name!=null||name.length()<10){
this.name=name;
}
}
//获取name属性值;
public String getName(){
return this.name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return this.age=age;
}
}
public class TestPerson {
public static void main(String[] args) {
/*
设计模式:一系列解决问题的方案 算法
23种,
单例设计模式:解决只让一个类在一个程序中创建一个唯一的对象;
*/
// Person zs=new Person();
// Person zs1=new Person();
Person zs=Person.creatPerson();
Person zs1=Person.creatPerson();
System.out.println(zs);
System.out.println(zs1);
}
}