/*
面向对象思路回顾:
1.他是相对面向过程而言,面向对象和面向过程都是一种编程思想
2.面向对象的特点
a.它比较符合人们行为思考习惯
b.将复杂事情简单化
c.它将我们由以前的执行者变成了指挥者
3.以后我们有功能需求时需要找相关的对象来帮我们完成,如果没有对应的对象,那么我们要自己来写这个对象供别人使用
*/
/*
代码块:
1.局部代码块 提高程序效率
2.构造函数
无参构造函数
3.构造代码块
每new一次对象时候都会调用一次构造代码块
对象在内存中初始化过程 Person p=new Person();
0.将Person.class字节码文件加载到内存中
1.在栈内存中初始化p,开辟一个空间给p;
2.给p默认初始化,将null赋值给p
3.在堆内存中初始化Person()对象
4.调用对象的构造代码块(如果有的话)
5.调用对象对应的构造函数(如果有的话)
6.将堆内存中的Person对象地址赋值给p
*/
class ObjectDemon1
{
public static void main(String[] args)
{
int num=4;//执行之后在虚拟机内消失了
System.out.println(num);//局部代码块
//System.out.println(num);//ObjectDemon1.java:23: 错误: 需要<标识符>
//调用无参构造函数
Person p=new Person();
System.out.println("********|*******");
//调用有參构造函数;
Person p1=new Person("109");
}
}
class Person
{
{
cry();
System.out.println("构造代码块");//先执行局部代码块,无关存放顺序
}
{
System.out.println("***************");//局部代码块有顺序
}
private String name;
//无参数构造函数
Person()
{
//cry();
System.out.println("无参构造函数");
}
//有参数构造函数
Person(String name)
{
//cry();
this.name=name;
System.out.println(name);
}
public static void cry()
{
System.out.println("哇哇");
}
}
*****************************************************************
<pre name="code" class="java">/*
static 关键字
用于修饰成员(成员变量和成员函数)
被修饰后的成员具备以下特点:
1.随着类的增加而增加
2.优先于对象存在
3.被所有对象所共享
4.可以直接被类名调用
注意:
1.静态方法只能访问静态成员
2.静态方法中不能用super,this关键字
3.主函数是静态的
静态在什么场景下适合使用?
所有的对象都有一个公共的属性值的时候
例子:学生--->(共用)饮水机,--->(学习)老师
*/
class Person
{
String name;//输于对象级别的成员属性
static String country="英国";//static修饰成员变量//属于所有对象共享的成员属性
public void showInfo()
{
System.out.println(name);
//System.out.println(this.name/country);这是正确的
System.out.println(country);
}
}
class StaticDemon2
{
public static void main(String[] args) //static修饰成员函数
{
Person p1=new Person();
p1.name="威廉";
//p1.country="英国";
p1.showInfo();
Person p2=new Person();
p2.name="凯特";
//p2.country="英国";
p2.showInfo();
//静态修饰的成员变量可以被所有对象共享
Person p3=new Person();
System.out.println("p3"+p3.name);
System.out.println("p3"+p3.country);
//可以通过类名方式 直接调用
System.out.println("类名方式 调用结果"+Person.country);
p3.country="美国";
System.out.println(Person.country);
System.out.println("p1:"+p1.country);
}
}
**********************************************************************************
<pre name="code" class="java">/*
静态变量和成员变量区别:
1.静态变量是随着累的加载而初始化,成员变量是随着对象的创建而初始化
静态变量生命周期和类是一直的, 成员变量的声明周期和对象是一致的
2.静态变量可以通过类名方式直接调用,通常叫做"类的变量"(非官方)
成员变量只能通过对象来调用,对象.属性(成员变量)
3.静态变量是存在方法区中的静态块
成员变量是在堆内存中的对象中
4.静态变量可以被所有的对象共享
成员变量只能局限于该对象使用
使用静态变量注意事项:
1.静态方法只能访问静态成员
普通方法可以去引用静态成员
2.静态方法中不能用super,this关键字//用静态方法的时候,对象还没有产生,怎么能调用this
3.主函数是静态的
*/
class Person
{
String name="破晓";
static String country="中国";
public void showInfo()
{
System.out.println(name);
System.out.println(country);
}
//"静态方法"里面无法应用非静态name
public static void showInfo1()
{
//System.out.println(name);//StaticDemon3.java:34: 错误: 无法从静态上下文中引用非静态 变量 name
System.out.println("1"+country);//System.out.println(this.country);//StaticDemon3.java:36: 错误: 无法从静态上下文中引用非静态 变量 this
System.out.println(Person.country);
}
}
class StaticDemon3
{
public static void main(String[] args)
{
Person p1=new Person();
p1.name="威廉";
//p1.country="英国";
p1.showInfo1();
Person p2=new Person();
p2.name="凯特";
//p2.country="英国";
p2.showInfo();
//静态修饰的成员变量可以被所有对象共享
Person p3=new Person();
System.out.println("p3"+p3.name);
System.out.println("p3"+p3.country);
//可以通过类名方式 直接调用
System.out.println("类名方式 调用结果"+Person.country);
p3.country="美国";
System.out.println(Person.country);
System.out.println("p1:"+p1.country);
}
}
***********************************************************************************
<pre name="code" class="java">/*
main函数详解
main是一个类的函数入口,jvm需要利用这个函数来做一个入口进入
不止java,c任何一门的主函数都叫main
static 原因: 通过类名方式StaticDemon4.main()直接调用,不需要创建对象后方才能调用
public 最大的访问权限,jvm任意调用
void "没有"--main函数没有返回值.jvm执行main函数 不需要 返回值
main 其他语言有可能Main ps:java语言中不能用大写的Main
String[]args 在什么地方才能给main函数传参数?在控制台调用java命令的时候可以直接传参
为什么要这么做?可以控制输入参数
*/
class StaticDemon4
{
public static void main(String[] args)
{
System.out.println(args);//变量的内存地址
System.out.println(args.length);//0
//拿到第一个参数
System.out.println(args[0]);//数组角标越界
System.out.println(args[1]);
for (int i=0;i<args.length ;i++ )
{
System.out.println(args[i]);
}
}
}
/*
静态构造代码块
总结:
<span style="white-space:pre"> </span> 1.不管创建多少个对象,静态构造代码块都只会执行一次
<span style="white-space:pre"> </span> 2.类加载时候就调用,相比构造函数是创建对象时候方便调用
<span style="white-space:pre"> </span> 构造代码块区别:
<span style="white-space:pre"> </span> 1.构造代码块每new一次都会被执行,但是静态代码块只会执行一次
<span style="white-space:pre"> </span>2.静态代码块会比构造代码块"先"执行
*/
class Person
{
<span style="white-space:pre"> </span>String name;
{
<span style="white-space:pre"> </span> System.out.println(this.name);
<span style="white-space:pre"> </span>
<span style="white-space:pre"> </span> }
<span style="white-space:pre"> </span>static
<span style="white-space:pre"> </span> {
<span style="white-space:pre"> </span> System.out.println("巴菲特");
<span style="white-space:pre"> </span> }
Person()
<span style="white-space:pre"> </span> {
<span style="white-space:pre"> </span> System.out.println(name);
<span style="white-space:pre"> </span> }
Person(String name)
<span style="white-space:pre"> </span> {
<span style="white-space:pre"> </span> this.name=name;
<span style="white-space:pre"> </span> System.out.println(name);
<span style="white-space:pre"> </span> System.out.println(this.name);
<span style="white-space:pre"> </span> }
}
class StaticDemon5
{
<span style="white-space:pre"> </span>public static void main(String[] args)
<span style="white-space:pre"> </span>{
<span style="white-space:pre"> </span>Person p1=new Person();
<span style="white-space:pre"> </span>Person p2=new Person("贝加特");
<span style="white-space:pre"> </span>Person p3=new Person("123");
<span style="white-space:pre"> </span>}
}
**************************************************************************
<pre name="code" class="java">/**
工具类设计思想
数组工具类:
1.打印数组到工具台
2.排序冒泡
3.最大值查询
4.根据元素值搜索返回角标
制作文档:javadoc
格式:javadoc -d arrayDoc -author -version ArrayTool6.java
前提条件:
@author lmd
@version 1.0
*/
public class ArrayTool6
{
/**
1.打印数组到工具台
@param int [] array 需要被打印的数组
*/
public static void print(int[] array)
{
for (int i=0;i<array.length ;i++ )
{
if(i==(array.length-1))
{
System.out.println(array[i]);
}
else
{
System.out.print(array[i]+",");
}
}
}
//2.冒泡排序
//private关键字描述访问权限,只有当前类才能访问
/**
在这里加文档注释没有任何意义,给自己的类用,不是给外面的类用
*/
private static void tihuan(int[]array,int x,int y)//静态
{
int tem=array[x];
array[x]=array[y];
array[y]=tem;
}
/**
@param 这是一排序 冒泡排序
*/
public static void sort(int[]array)
{
for (int x=0;x<array.length ;x++ )
{
for (int y=x+1;y<array.length ;y++ )
{
if(array[x]>array[y])
{
tihuan(array,x,y);
}
}
}
}
//3.最大值查询
/**
最大值查询
@param int[]array 需要获取的数组
@return int 返回最大值
*/
public static int getMax(int[]array)
{
int tem=array[0];
for (int i=0;i<array.length ;i++)
{
if (array[i]>tem)
{
tem=array[i];
}
}
return tem;
}
//4.根据元素值搜索返回脚标
/**
根据元素值搜索返回脚标
@param int[] array 被查询的数组
@param int value 需要查询的值
@return int 返回值所在的数组中的脚标
*/
public static int getIndexByValue(int[]array,int value)
{
int index=-1;
for (int i=0;i<array.length ;i++ )
{
if (value==array[i])
{
index=i;
}
}
return index;
}
}
*********************************************************************************
<pre name="code" class="java">/*
当我们在一个类中引用另一个的时候,首先会去找该类的class的文件,
如果找不到class文件就回去找对应的java文件,自动编译该类
优化;
1.工具类中的方法都是共性的,不是针对哪个对象而存在的
2.将内部调用的方法私有化
*/
class ArrayTest7
{
public static void main(String[] args)
{
int[]array1=new int []{1,3,2,6,5};
/*
ArrayTool6 tool=new ArrayTool6();
{
tool.print(array1);
}
*/
//当所有的类共用一样的方法
//使用类直接调用方法
ArrayTool6.print(array1); // 打印
ArrayTool6.sort(array1);
for(int i=0;i<array1.length;i++) //冒泡排序
{
System.out.print(array1[i]+",");
}
System.out.println();
System.out.println("****************");
int Max=ArrayTool6.getMax(array1); //最大值
System.out.println(Max);
int Index=ArrayTool6.getIndexByValue(array1,3); //找脚标
System.out.println(Index);
}
}
*(*********************************************************************
<pre name="code" class="java">/*
单列设计模式
设计模式是一种思想,不是具体代码实现
单列设计模式:在内存中保证只有一个对象
如何保证内存中只有一个对象?
1.我将构造函数私有化(new)
2.类内部应该自己创建一个对象
3.向外提供一个方法获取这个对象.
*/
class Person
{
//1.我将构造函数私有化(new)
private Person(){}
//2.类内部应该自己创建一个对象 为了能让静态函数调用,需要使用static修饰 为了不能让外面的类直接访问p变量,需要private修饰
private static Person p=new Person();
//3.向外提供一个方法获取这个对象. 为了能让外面的类直接调用 需要用static修饰
public static Person getPerson()
{
return p;
}
//添加:
public void show()
{
System.out.println("hello");
}
}
class SingleDemon801
{
public static void main(String[] args)
{
//如何判断两个对象是否是一个?
/*
Person p1=new Person();
Person p2=new Person();
System.out.println(p1==p2);
*/
//System.out.println(Person.p);//可以直接调用19行中的p
Person p1=Person.getPerson();
Person p2=Person.getPerson();
System.out.println(p1==p2);
Person p3=Person.getPerson();
System.out.println(p2==p3);
//添加:
p1.show();
p2.show();
p3.show();
}
}
****************************************************************************
<pre name="code" class="java">/*
单列设计模式 第二种方式
设计模式是一种思想,不是具体代码实现
单列设计模式:在内存中保证只有一个对象
如何保证内存中只有一个对象?
1.我将构造函数私有化(new)
2.类内部应该自己创建一个对象
3.向外提供一个方法获取这个对象.
两种设计方式的区别:
第一种 类加载的时候就创建了对象
第二种 需要的时候才会去创建对象
在工作当中有个叫法
第一种是饿汉式
第二种是懒汉式
开发当中要用第一种
面试中使用第二种 线程安全问题
*/
class Person
{
//1.我将构造函数私有化(new)
private Person(){}
//2.类内部应该自己创建一个对象 为了能让静态函数调用,需要使用static修饰 为了不能让外面的类直接访问p变量,需要private修饰
private static Person p=null;
//3.向外提供一个方法获取这个对象. 为了能让外面的类直接调用 需要用static修饰
public static Person getPerson()
{
if (p==null)
{
p=new Person();//不使用,就不会在堆内存中开辟这个空间,节省
}
return p;
}
//添加
public void show()
{
System.out.println("hello");
}
}
class SingleDemon9
{
public static void main(String[] args)
{
//如何判断两个对象是否是一个?
//Person p1=new Person();
// Person p2=new Person();
//System.out.println(p1==p2);
//System.out.println(Person.p);//可以直接调用19行中的p
Person p1=Person.getPerson();
p1.show(); //---------- java ----------
//Exception in thread "main" java.lang.NullPointerException//空指针异常
//at SingleDemon9.main(SingleDemon9.java:52)
//System.out.println(p1);//null
Person p2=Person.getPerson();
System.out.println(p1==p2);
//Person p2=Person.getPerson();
//System.out.println(p1==p2);
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
