public class CarDemo {
public static void main(String[] args) {
// 在计算机中创建一个car的实例,通过new关键字.
Car c = new Car(); // c 就是 一个类类型的引用变量,指向了该类型的对象.
c.num = 4;
c.color = "red";
c.run(); // 要使用对象中的内容可以通过 对象.成员 的形式来完成调用
/*
* 匿名对象,没有名字的对象.
* new Car(); //匿名对象,其实就是定义对象的简写格式.
*
* Car c = new Car();
* new Car().run();
*
* 1.当对象对方法仅进行一次调用的时候,就可以简化成匿名对象.
* 2.匿名对象可以作为实际参数进行传递.
*/
Car c1 = new Car() ;
Car c2 = new Car() ;
show(c1);
show(c2);
show(new Car()) ;
}
public static void show(Car c) { //类类型的变量一定指向变量,要不就是null
c.num = 3;
c.color = "black";
System.out.println(c.num+"..."+c.color);
}
}
class Car {
int num = 6;
String color;
void run() {
System.out.println(num + "..." + color);
}
}
import com.sun.org.apache.regexp.internal.recompile;
public class ConsDemo {
/*
* 构造函数:构建创造对象时调用的函数.
* 作用:可以给对象进行初始化.
* 创建对象都必须要通过构造函数初始化.
* 一个类中如果没有定义过构造函数,那么该类中会有一个默认的空参数构造函数.
* 如果在类中定义了指定的构造函数,那么类中的默认构造函数就没有了.
*
* 一般函数和构造函数有什么区别?
*构造函数:对象创建时,就会调用与之对应的构造函数,对对象进行初始化.
*一般函数:对象创建后,需要函数功能时才调用.
*
*构造函数:对象创建时,会调用且只调用一次.
*一般函数:对象创建后,可以调用多次.
*
*什么时候定义构造函数呢?
*在描述事物时,该事物已存在就具备的一些内容,这些内容都定义在构造函数中.
*/
public static void main(String[] args) {
// Person_2 p = new Person_2() ;
// p.speak();
// Person_2 p1 = new Person_2("旺财") ;
// p1.setName("王娅");
// p1.speak();
// Person_2 p2 = new Person_2("小强", 10) ;
// p2.speak();
Person_2 p1 = new Person_2("aa",30) ;
Person_2 p2 = new Person_2("bb",40) ;
}
}
class Person_2{
private String name ;
private int age ;
//定义一个Person类的构造函数.
Person_2() { //构造函数,而且是空参数的.
name = "baby" ;
age = 1;
System.out.println("person run");
}
Person_2(String n) {
name = n;
}
Person_2(String n,int a) {
name = n;
age = a ;
}
public void speak() {
System.out.println(name+":"+age+"岁");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class MainDemo {
/*
主函数特殊之处:
1.格式是固定的.
2.被jvm所识别和调用.
public:因为权限必须是最大的.
static:不需要对象的.直接用主函数所属类名调用即可.
void:主函数没有具体的返回值.
main:函数名,不是关键字,只是一个jvm识别的固定的名字.
String[] args:这是主函数的参数列表,是一个数组类型的参数,而且元素都是字符串类型.
*/
public static void main(String[] args) {
System.out.println(args); //[Ljava.lang.String;@3781efb9
System.out.println(args.length);
for(int x = 0; x<args.length; x++) {
System.out.println(args[x]);
}
}
}
public class PersonDemo {
public static void main(String[] args) {
Person p = new Person();
// p.age = -20 ;
p.setAge(20);
// p.speak();
}
}
class Person {
private int age; // 私有
void speak() {
System.out.println("age=" + age);
}
public void setAge(int a) {
if (a > 0 && a < 130) {
age = a;
speak();
} else {
getAge() ;
}
}
public int getAge() {
System.out.println("输入错误,请重新输入!!!");
return age ;
}
/*
public void input(int a) {
if (a > 0 && a < 130) {
age = a;
speak();
} else {
System.out.println("输入错误!");
}
}
*/
}
/*
静态代码块:
随着类的加载而执行.而且只执行哦一次,
作用:
用于给类进行初始化.
*/
public class StaticCodeDemo {
public static void main(String[] args) {
// new StaticCode().show();
// new StaticCode().show();
// StaticCode.show
Person_5 p1 = new Person_5() ;
p1.speak();
Person_5 p2 = new Person_5("旺财") ;
p2.speak();
}
}
class StaticCode {
static int num ;
static {
num = 10 ;
System.out.println("hellow");
}
static void show() {
System.out.println(num);
}
}
class Person_5{
private String name ;
{ //构造代码块,可以给所有对象进行初始化.
// System.out.println("person run");
cry() ;
}
Person_5() { //构造函数是给对应的对象进行针对性的初始化.
name = "baby" ;
}
Person_5(String name) {
this.name = name ;
}
public void speak() {
System.out.println("name:"+name);
}
public void cry() {
System.out.println("哇哇");
}
}
public class StaticDemo {
public static void main(String[] args) {
Person_4 p = new Person_4();
p.setName("小强");
p.show();
}
}
/*
static的特点:
1.static是一个修饰符,用于修饰成员.
2.static修饰的成员被所有的对象所共享.
3.static优先于对象存在,因为static的成员随着类的加载就已经存在了.
4.static修饰的成员多了一种调用方式,就是可以直接被类名所调用. 类名.静态成员
5.static修饰的数据是共享数据,对象在存储的是特有数据.
*/
class Person_4 {
private String name; //成员变量,实例变量
static String country = "CN"; //静态变量,类变量
public void show() {
System.out.println(Person_4.country + ":" + this.name);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/*
静态什么时候用?
1.静态变量:
当分析对象中的成员变量的值都是相同的,这时这个成员就可以被静态修饰.
只要成员变量的值在对象中是不同的,就是对象的特有的值.必须存储在对象中,是非静态的.
如果成员变量的值在对象中的值是相同的,对象不需要修改值,只需要使用即可,不需要存储在对象中.
就定义成静态的.
2.静态函数:
函数是否用静态修饰,就参考一点.就是该函数功能是否有访问到对象中的特有数据.
简单说,从代码看,该功能是否需要访问非静态的成员变量.如果需要,该功能就是非静态的.
如果不需要,就可以将该功能定义成静态的.当然,也可以定义为非静态.但是非静态需要被对象调用,
如果创建对象仅仅只调用函数而不需要访问特有数据,该对象的创建没有意义.
*/
public class StaticDemo2 {
public static void main(String[] args) {
}
}
class Demo {
int num = 9 ;
}
public class ThisDemo {
public static void main(String[] args) {
Person_3 p1 = new Person_3("张三", 30);
Person_3 p2 = new Person_3("李四",40);
p2.compare(p1) ;
}
}
/*
* 当成员变量和局部变量重名,可以用关键字 this 来区分. this:代表当前对象. this就是所在函数所属对象的引用.
* 简单说:那个对象调用了this所在的函数,this就代表哪个对象.
* this也可以用于在构造函数中调用其他构造函数.
* 注意:只能定义在构造函数的第一行,因为初始化动作要先执行.
*/
class Person_3 {
private String name;
private int age;
Person_3() { //构造函数,而且是空参数的.
name = "baby" ;
age = 1;
System.out.println("person run");
}
Person_3(String name) {
this.name = name;
}
Person_3(String name, int age) {
this(name) ;
this.age = age;
/*
if(this.age < 1) {
System.out.println("输入错误,请重新输入!!!");
return ;
// }else if(this.age == 0){
// System.out.println("输入错误,请重新输入!!!");
// return ;
}else{
this.speak();
}
*/
}
/*
* 判断是否是同龄人.
*/
public boolean compare(Person_3 p) {
/*
if(this.age == p.age) {
System.out.println("true");
return true ;
}else{
System.out.println(false);
return false ;
}
*/
return this.age == p.age ;
}
void speak() {
System.out.println(this.name + ":" + this.age + "岁");
}
}
对象
最新推荐文章于 2024-08-30 11:04:08 发布