public class Demo {
public static void main(String[] args) {
Person zhangsan = new Person();
zhangsan.name = "张三";
zhangsan.age = 18;
System.out.println(zhangsan.name);
System.out.println(zhangsan.age);
}
}
public class Person {
String name;
int age;
public void work(){
System.out.println("工作");
}
}
public class Person {
String name;
int age;
//一个类即使什么都不写,也会存在一个构造器
//idea构造器快捷键:alt + insert
//使用new关键字,本质就是调用构造器
//构造器用来初始化
public Person() {
}
//有参构造:一旦定义了有参构造,想使用无参构造,就必须显示定义无参构造
public Person(String name) {
this.name = name;
}
public Person(String name,int age) {
this.name =name;
this.age = age;
}
}
public class Application {
public static void main(String[] args) {
Pet dog = new Pet();
dog.name = "旺财";
dog.age = 3;
dog.shout();
Pet cat = new Pet();
}
}
public class Pet {
public String name;
public int age;
public void shout(){
System.out.println("叫");
}
}
public class Demo {
public static void main(String[] args) {
Person person = new Person();
person.setName("张三");
System.out.println(person.getName());
}
}
public class Person {
//属性私有
private String name;
private int age;
//提供一些可以操控这些属性的方法
//提供一些public的get、set方法
public String getName(){
return this.name;
}
public void setName(String name){
this.name = name;
}
}
public class Person {
private int money = 10_0000_0000;
public void say(){
System.out.println("说话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
//子类继承父类就会拥有父类的所有方法,不能直接继承private属性,可通过public方法来使用private定义的属性
public class Student extends Person{
//Ctrl + H
}
public class Person {
protected String name = "名字";
public void print(){
System.out.println("Person");
}
}
public class Student extends Person{
private String name = "学生";
public Student(){//父类如果没有无参构造,只有有参构造,则子类无法创建无参构造
//隐藏代码:调用父类的无参构造
super();//调用父类的构造器,必须在子类构造器的第一行
//this("zhangsan");//子类构造器只能单独调this和super之一
}
public Student(String name){
this.name = name;
}
public void print(){
System.out.println("Student");
}
public void test(String name){
print();
this.print();
super.print();
}
}
public class Demo {
public static void main(String[] args) {
Student student = new Student();
student.test("张三");
}
}
ClassNotFoundException-->Exception(大)
重写,子类的方法和父类必要一致:方法体不同!
为什么需要重写:
//重写都是方法的重写,与属性无关
public class B {
public static void test(){
System.out.println("B.test");
}
public void test1(){
System.out.println("B.test");
}
}
public class A extends B{
public static void test(){
System.out.println("A.test");
}
public void test1(){
System.out.println("B.test");
}
}
public class Demo {
public static void main(String[] args) {
//静态方法和非静态方法的区别很大
//静态方法:方法的调用只和左边定义的数据类型有关
//非静态方法:重写
A a = new A();
a.test();
a.test1();
//父类的引用指向子类
B b = new A();
b.test();
b.test1();//子类重写了父类的方法
}
}
Father f = new Son()
Dog dog = new Dog();
Animal animal = new Animal();
Animal dog = new Dog();
System.out.println(dog instanceof Dog); // true
System.out.println(dog instanceof Animal); // true
System.out.println(animal instanceof Animal); // true
System.out.println(animal instanceof Dog); // false
System.out.println(animal instanceof String); // 编译时报错
//类型之何的转化:父
//子类转换为父类,可能丢失自己的本米的一些方法!
Student student = new Student();
Person person = student;
//abstract 抽象类。 extends:单继承。
public abstract class Action {
//约束,有人帮我们实现~
//abstract 抽象方法,只有方法名字,没有方法的实现!
public abstract void doSomething();
}
//抽象类的所有方法,继承了它的了类,都必须要实现它的方法。除非该子类也是抽象类。
public class A extends Action {
@Override
public void doSomething(){}
}
//interface 定义的关键字 , 接口都需要有实现类
public interface UserService {
//接口中所有定义其实都是抽象的 public abstract
int Age = 18;//接口中的属性是常量 public static final
public abstract void add(String name);
void delete(String name);
void update(String name);
void search(String name);
}
public interface TimeService {
void timer();
}
//类可以实现接口 implements 接口
//实现了接口的类,就需要重写接口的方法
//多继承~利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void search(String name) {
}
@Override
public void timer() {
}
}
内部类就是在一个类的内部在定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类。
public class Outer {
private int id;
public void out(){
System.out.println("out");
}
//成员内部类
class Inner1{
public void in(){
System.out.println("in");
}
public void getId(){//可以获取外部类中的私有方法
System.out.println(id);
}
}
//静态内部类
public static class Inner2{
}
//局部内部类
public void method(){
class Inner3{
}
}
public static void main(String[] args) {
//没有名字初始化类,不用将实例保存到变量中 : 匿名内部类
new Inner().eat();
new InService(){
@Override
public void hello() {
}
};
}
}
//成员内部类
class Inner{
public static void main(String[] args) {
}
public void eat(){
System.out.println("eat");
}
}
interface InService{
void hello();
}
本文章使用limfx的vscode插件快速发布