一、创建对象系统进程
二、static关键字
-
static关键字的特点:
1)static 随着类的加载而加载 (生命周期----->xxx.class :static相关的都先进内存! )
2)优先于对象存在
类的加载:类名.class (优先的)
对象的创建:类名 对象名 =new 类名() ;3)不能和this共用!
4)被静态修饰的变量/方法—>(称为 “静态变量”,“静态方法”):有共享,共用的意思
举例:
水杯中的水 :不能被共用的
饮水机:可以被共用!
5)被静态修饰的变量或者方法,推荐使用的类名访问
类名.静态变量名;
类名.静态方法名() ;
6)不推荐使用:类名 对象名 = new 类名() ;
对象名.静态变量名;
对象名.静态方法名() ;
举例：
//Demo类
class Demo{
//成员变量
int num = 10 ;
//静态变量
static int num2 = 20 ;
//成员方法
public void function(){
System.out.println("function demo...") ;
}
//静态方法
public static void method(){
System.out.println("method demo...") ;
}
}
//测试类
class StaticDemo{
public static void main(String[] args){
//需求:要访问Demo类中的num和num2变量?
Demo d = new Demo() ;
System.out.println(d.num) ;
//System.out.println(d.num2) ; //静态变量不这样访问:不推荐!
System.out.println(Demo.num2) ; //静态的成员的访问方式
System.out.println("---------------------") ;
d.function() ;
//d.method() ;//不推荐
//推荐方式
Demo.method() ;
}
}
- 关于static静态的使用注意事项:
1)非静态的成员方法:
可以访问静态的成员变量,也可以访问非静态的变量!
包括静态方法或者非静态方法
简单记:非静态的可以访问静态的成员/非静态的…
2)静态的方法
静态只能访问静态! (这些静态变量/方法都是跟类相关的!)
举例：
//Demo类
class Demo{//Demo.class
//静态
public static int number = 100 ;
//非静态
public int number2 = 20 ;
//非静态的成员方法
public void show(){
System.out.println(number2) ;
System.out.println(number) ;
System.out.println("-------------------") ;
function() ;//静态方法
method() ;
}
public void method(){
System.out.println("method demo") ;
}
//静态方法
public static void function(){
//System.out.println(number2) ; //无法从静态上下文中引用非静态 变量 number2
System.out.println(number) ;
System.out.println("function demo") ;
//method() ;//无法从静态上下文中引用非静态 方法 method()
}
}
//测试类
class StaticDemo2{
public static void main(String[] args){
//创建Demo类对象
Demo d = new Demo() ;
d.show() ;
System.out.println("---------------");
Demo.function() ;
}
}
举例3：
/*
需求:
人是一个事物,有姓名,年龄,国籍的属性
定义一个类,能够来描述人的属性,
有一个show方法,就是将人的属性展示出来
存在问题:
这四个人都是"中国",这个字段 "冗余",在堆内存中,每一个对象都需要给country赋值,
消耗内存空间,如何解决?
Java提供了一个关键字:static :可以被多个对象"共享,共用"
在country这个属性上加入static关键字
*/
//定义一个类:人类
class Person{//Preson.class
private String name ; //姓名
private int age ; //年龄
static String country ;//国籍
//有参构造方法
//带两个参数的构造方法
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public Person(String name,int age ,String country){
this.name = name ;
this.age = age ;
this.country = country ;
}
public void show(){
System.out.println("这个人姓名是-"+name+",年龄是-"+age+",所在的国籍是-"+country) ;
}
}
//测试类
class PersonTest{
public static void main(String[] args){
//古代四大美女
Person p1 = new Person("西施",18,"中国") ;
p1.show() ;
System.out.println("------------------------") ;
//Person p2 = new Person("貂蝉",25,"中国") ;
Person p2 = new Person("貂蝉",25) ;
p2.show() ;
System.out.println("------------------------") ;
//Person p3 = new Person("杨玉环",28,"中国") ;
Person p3 = new Person("杨玉环",28) ;
p3.show() ;
System.out.println("------------------------") ;
//Person p4 = new Person("王昭君",23,"中国") ;
Person p4 = new Person("王昭君",23) ;
p4.show() ;
System.out.println("------------------------") ;
p1.country = "美国" ;
p1.show() ;
p2.show();
p3.show();
p4.show() ;
}
}
三、制作文档说明书
-
产生文档说明书:针对ArrayTool.java文件产生API 文档解析
进入到本地目录下: 使用javadoc -d doc(目录名字) -author -version ArrayTool.java(针对哪个Java文件产生文档解析)以后使用的API (Application Programming Interface)
打开jdk提供的JDK6/JDK7/JDK8: 文档之后,点击索引 "输入你要查询的类或者接口" 进去之后: 看这个类的字段(成员变量) 构造方法:有几种方式创建该类对象 方法(成员方法):有哪些功能
举例：
/**
这是针对数组操作的自定义工具类
@author Apple
@version V1.0
*/
//就让这个类的权限足够大
public class ArrayTool{
//隐藏了:私有化了
private ArrayTool(){
}
/**
这个功能是针对数组的遍历功能,将元素一一获取出来
最终的结果是[元素1, 元素2, 元素3, ...]
@param arr 这个参数是将指定的数组进行遍历
*/
public static void printArray(int[] arr){
System.out.print("[") ;
//遍历数组
for(int x = 0 ; x < arr.length ; x ++){
//判断
if(x == arr.length-1){
System.out.println(arr[x] +"]") ;
}else{
System.out.print(arr[x]+", ") ;
}
}
}
/**
该功能是获取数组中的最大值
@param arr 在指定对数组中查找最大值
@return 返回就是获取的数组中的最大值max
*/
public static int getMax(int[] arr){
//参照物
int max = arr[0] ;
for(int x = 1 ; x < arr.length ; x ++){
if(arr[x] > max){
max = arr[x] ;
}
}
return max ;
}
/**
该功能是查询指定的元素在数组中出现的索引值
@param arr 当前在指定的数组中查找
@param key 要查找的指定的元素
@return 返回查询到的元素在数组中的索引值
*/
public static int getIndex(int[] arr,int key){
//使用假设法
int index = -1 ;
for(int x = 0 ; x < arr.length ; x ++){
//判断
if(arr[x] == key){
index = x ;
break ;
}
}
return index ;
}
/**
这个功能是对数组进行冒泡排序
@param arr 对指定的数组进行排序
*/
public static void bubbleSort(int[] arr){
for(int x = 0 ; x < arr.length -1 ; x ++){
for(int y = 0 ; y < arr.length-1-x ; y ++){
if(arr[y] > arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = temp ;
}
}
}
}
}
//测试类main方法：
//测试类
class ArrayDemo{
public static void main(String[] args){
//创建一个数组,静态初始化
int[] arr = {66,15,78,45,23} ;
//使用类名.访问方法名即可
ArrayTool.printArray(arr) ;
System.out.println("--------------") ;
int max = ArrayTool.getMax(arr) ;
System.out.println("数组中的最大值是:"+max) ;
System.out.println("--------------") ;
int index = ArrayTool.getIndex(arr,45) ;
System.out.println("index:"+index) ;
System.out.println("--------------") ;
ArrayTool.bubbleSort(arr) ;
ArrayTool.printArray(arr) ;
}
}
四、代码块
- 在Java中,使用{}包裹起来的代码,都称为"代码块"
- 代码块的分类:
1). 局部代码块:
在局部位置(方法定义中){xx},作用, 限定局部变量的生命周期,不能超过这个范围访问
2). 构造代码块:
在类的成员位置中使用{}包裹起来的代码,
作用将多个构造方法中相同的代码存储在构造代码块中,在执行构造方法之前先执行,对数据进行初始化!
特点:每次执行构造方法之前,如果存在构造代码块,优先执行构造代码块,在执行构造方法!
3). 静态代码块:
在类的成员位置:
static{
…
}
静态随着类的加载而加载,类加载一次,静态代码块就执行一次,静态代码块优先执行! - 构造代码块,构造方法,静态代码块的优先级
静态代码块(后期使用到:第二阶段:JDBC) > 构造代码块 > 构造方法 !
代码块的优先级:
静态代码块> 构造代码块>构造方法
静态代码块随着类的加载而加载,由于类就加载一次,静态代码块就执行一次!
举例1：
//定义一个类Code
class Code{
//静态代码块
static{
int x = 1000 ;
System.out.println(x) ;
}
//构造代码块
{
int x = 100 ;
System.out.println(x) ;
}
//无参构造方法
public Code(){
System.out.println("code...") ;
}
//有参构造
public Code(int num){
System.out.println("code"+num) ;
}
//构造代码块
{
int y = 200 ;
System.out.println(y) ;
}
static{
int y = 2000 ;
System.out.println( y ) ;
}
}
//测试类
class CodeDemo{
public static void main(String[] args){
//局部代码块
{
int x = 10 ;
System.out.println(x) ;//10
}
System.out.println("------------------") ;
//System.out.println(x) ;无法变量x
//创建Code类对象
Code c = new Code() ;
System.out.println("------------------") ;
Code c2 = new Code(10) ;
}
}
举例2：
class Student{
static{
System.out.println("student的静态代码块1") ;
}
{
System.out.println("student的构造代码块1") ;
}
public Student(){
System.out.println("Student类的无参构造方法") ;
}
static{
System.out.println("student的静态代码块2") ;
}
public Student(String name){
System.out.println("Student类的有参构造方法") ;
}
{
System.out.println("student的构造代码块2") ;
}
}
class StudentTest{
static{
System.out.println("高圆圆41了...") ;
}
public static void main(String[] args){
System.out.println("我是main方法...") ;
Student s = new Student() ;
System.out.println("-----------") ;
Student s2 = new Student("高圆圆") ;
}
}
五、定义成员变量
成员变量：当前这个变量能够描述真实事物的属性,将变量定义成员变量;
局部变量：不能够体现出现真实事物的属性,将变量定义局部变量;
没有明确要求的情况下,都优先定义为局部变量,局部变量随着方法调用而存在,随着方法调用结束而消失!
举例：
/*
需求:
长方形:
键盘录入长方形的长和宽,分别求出这个长方形的周长和面积!
分析:
长方形是真实事物:
两个属性:长和宽 ----长和宽定义为成员变量(私有修饰)
周长和面积: 长方形事物的行为!
定义一个长方形类(Ract)
length和width
*/
import java.util.Scanner ;
class Ract{
//成员变量
private int length ; //长
private int width ; //宽
//set方法赋值
public void setLength(int length){
this.length = length ;
}
public void setWidth(int width){
this.width = width ;
}
//求周长的功能
public int getZhouChang(){
return (length+width)*2;
}
//求面积
public int getArea(){
return length * width ;
}
}
//测试类
class Test{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请输入长:") ;
int length = sc.nextInt() ;
System.out.println("请输入宽:") ;
int width = sc.nextInt() ;
//封装长方形类
Ract r = new Ract() ;
r.setLength(length) ;
r.setWidth(width) ;
//输出
System.out.println("该长方形的周长是:"+r.getZhouChang()) ;
System.out.println("该长方形的面积是:"+r.getArea()) ;
}
}
六、继承
- 定义：将多个类的共性内容抽取在一个独立的类中,然后独立的类和这些类产生一种"继承"关系
extends - Java提供的"继承" 特征 的好处:
1)提高了代码的复用性
2)提高了的代码的维护性
3)让类与类之间产生关系 ----- 是 “多态的前提条件” - Java开发原则:
开闭原则(经常使用到: 对修改关闭,对扩展开放)
迪米特原则
接口分离原则
依赖注入原则
… - 开发中,设计原则: 都要遵循
“低耦合,高内聚”
耦合:类与类的产生的关系
低耦合:这种关系越少越好! “耦合”----只能避免,不能彻底解决!(Spring框架:IOC 控制反转)
内聚:执行某件事情的能力
高内聚:在一个类中能够完成的事情,不要使用多个类完成事情! - 注意事项1:
子类继承父类,只能继承父类非私有的成员,私有的成员,外界不能访问的,只能间接通过
公共方法访问!
子类中的功能:一般都是一些子类的特有功能
举例1：
//学生姓名和年龄
class Student{
private String name ;
prvate int age ;
public Student(){}
public Student(String name,int age){
this.name = name ;
this.age = age ;
}
//...setXXX()/getXXX()
//eat()
//sleep()
}
//老师类,姓名和年龄
class Teacher{
private String name ;
prvate int age ;
public Teacher(){}
public Teacher(String name,int age){
this.name = name ;
this.age = age ;
}
//...setXXX()/getXXX()
//eat()
//sleep()
}
在开发中,可能定义各种各样的类,他们都有一些属性姓名,年龄, 定义军人类,工人类等等,将
这些类中共性内容抽取到一个独立的类中,然后让这个独立的类和这些多个类产生一种关系 :"继承" (extends)
格式:
class 父类名{}
class 子类名 extends 父类名{}
改造上面代码:
class Person{
private String name ;
prvate int age ;
public Person(){}
//有参构造方法
//setXXX()/getXXX()
//eat()
//sleep()
}
class Student extends Person{}
class Teacher extends Person{}
``
举例2：
//父类
class Father{
private int num = 20 ; // num 在 Father 中是 private 访问控制
public int num2 = 30 ;
public void show(){
System.out.println( num) ;
function() ;
}
private void function(){
System.out.println("function father...") ;
}
}
//子类
class Son extends Father{
public void playGame(){
System.out.println("玩游戏...") ;
}
}
//测试类
class ExtendsDemo2{
public static void main(String[] args){
//创建子类对象
Son s = new Son() ;
//System.out.println(s.num) ;
System.out.println(s.num2) ;
s.show() ;
//s.function() ;
s.playGame() ;
}
}
1231
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
